https://tc39.es/ecma262/ 문서는 가장 정확하고 최신의 ECMAScript 명세입니다. 이 문서에는
최근 연간 스냅샷의 내용과 스냅샷 이후에 완료된 모든 완료된 제안 (제안 프로세스에서 Stage 4에 도달하여 여러 구현에서 적용되었고 다음 실질적인 개정에 포함될
예정인 것)이 포함되어 있습니다.
이 Ecma 표준은 ECMAScript 2026 언어를 정의합니다. 이것은 ECMAScript 언어 명세의 열일곱 번째 에디션입니다. 1997년 첫 번째 에디션이 출판된 이후,
ECMAScript는 세계에서 가장 널리 사용되는 범용 프로그래밍 언어 중 하나로 성장했습니다. 주로 웹 브라우저에 내장된 언어로 잘 알려져 있지만, 서버 및 임베디드 애플리케이션에서도
널리 채택되었습니다.
ECMAScript는 여러 원천 기술을 기반으로 하며, 그 중 가장 잘 알려진 것은 JavaScript(넷스케이프)와 JScript(마이크로소프트)입니다. 이 언어는 넷스케이프의
Brendan Eich가 발명했으며, 처음으로 그 회사의 Navigator 2.0 브라우저에 등장했습니다. 이후 넷스케이프의 모든 브라우저와 마이크로소프트의 Internet
Explorer 3.0부터 모든 브라우저에 포함되었습니다.
ECMAScript 언어 명세의 개발은 1996년 11월에 시작되었습니다. 이 Ecma 표준의 첫 번째 에디션은 1997년 6월 Ecma 총회에서 채택되었습니다.
그 Ecma 표준은 ISO/IEC JTC 1에 신속 채택 절차 하에 제출되었으며, 1998년 4월 국제 표준 ISO/IEC 16262로 승인되었습니다. 1998년 6월 Ecma 총회에서
ISO/IEC 16262와 완전히 일치시키기 위해 ECMA-262 두 번째 에디션이 승인되었습니다. 첫 번째와 두 번째 에디션의 차이점은 편집상의 변경입니다.
표준의 세 번째 에디션에서는 강력한 정규식, 향상된 문자열 처리, 새로운 제어문, try/catch 예외 처리, 오류 정의 강화, 숫자 출력 포맷 및 향후 언어 성장에 대비한 사소한 변경이
도입되었습니다. ECMAScript 표준의 세 번째 에디션은 1999년 12월 Ecma 총회에서 채택되었으며, 2002년 6월 ISO/IEC 16262:2002로 출판되었습니다.
세 번째 에디션 출판 이후, ECMAScript는 월드와이드웹과 함께 엄청난 채택을 이루었으며, 사실상 모든 웹 브라우저에서 지원되는 프로그래밍 언어가 되었습니다. ECMAScript의 네
번째 에디션을 개발하기 위한 중요한 작업이 이루어졌으나, 그 작업은 완성되지 않았고 네 번째 에디션으로 출판되지 않았습니다. 다만 일부 내용은 여섯 번째 에디션 개발에 통합되었습니다.
ECMAScript의 다섯 번째 에디션(ECMA-262 5번째 에디션으로 출판됨)은 브라우저 구현에서 일반적으로 사용되는 언어 명세의 사실상 해석을 공식화하였고, 세
번째 에디션 출판 이후 등장한 새로운 기능 지원을 추가했습니다. 이러한 기능에는 접근자 속성, 객체의 반영적 생성 및 검사, 속성 특성의 프로그램 제어, 추가 배열 조작 함수,
JSON 객체 인코딩 포맷 지원, 그리고 향상된 오류 검사와 프로그램 보안을 제공하는 엄격 모드가 포함됩니다. 다섯 번째 에디션은 2009년 12월 Ecma 총회에서 채택되었습니다.
다섯 번째 에디션은 신속 채택 절차에 따라 ISO/IEC JTC 1에 제출되어 국제 표준 ISO/IEC 16262:2011로 승인되었습니다. ECMAScript 표준의 5.1 에디션은
사소한 수정이 반영되었으며 ISO/IEC 16262:2011과 동일한 텍스트입니다. 5.1 에디션은 2011년 6월 Ecma 총회에서 채택되었습니다.
여섯 번째 에디션의 집중 개발은 2009년에 시작되었으며, 다섯 번째 에디션이 출판 준비 중이었습니다. 하지만 그 이전에도 1999년 세 번째 에디션 출판 이후 상당한 실험과 언어 개선
디자인 작업이 이루어졌습니다. 실제로 여섯 번째 에디션의 완성은 15년간의 노력의 결실입니다. 이 에디션의 목표는 대규모 애플리케이션, 라이브러리 제작, 그리고 ECMAScript를 다른
언어의 컴파일 타겟으로 사용하는 데 더 나은 지원을 제공하는 것이었습니다. 주요 개선사항에는 모듈, 클래스 선언, 렉시컬 블록 스코프, 이터레이터와 제너레이터, 비동기 프로그래밍을 위한 프라미스, 구조 분해 패턴, 적절한 꼬리
호출이 포함되었습니다. ECMAScript 내장 라이브러리는 맵, 셋, 2진 숫자 값 배열 등의 추가 데이터 추상화 지원과 문자열 및 정규식에서 유니코드 보충 문자 추가 지원을 포함하여
더욱 확장되었습니다. 내장 객체는 서브클래싱을 통해 확장 가능해졌습니다. 여섯 번째 에디션은 정기적이고 점진적인 언어 및 라이브러리 개선의 토대를 제공합니다. 여섯 번째 에디션은
2015년 6월 총회에서 채택되었습니다.
ECMAScript 2016은 Ecma TC39의 새로운 연간 릴리즈 주기와 공개 개발 프로세스 하에서 릴리즈된 첫 번째 ECMAScript 에디션입니다. 텍스트 소스 문서는
ECMAScript 2015 소스에서 제작되어 GitHub에서 추가 개발의 기반이 되었습니다. 표준 개발 기간 동안 수백 개의 풀 리퀘스트와 이슈가 제출되어 수천 건의 버그 수정, 편집
개선 및 기타 향상 작업이 이루어졌습니다. 또한 Ecmarkup, Ecmarkdown, Grammarkdown 등 여러 소프트웨어 도구가 개발되었습니다. ES2016에는 새로운 거듭제곱
연산자와 Array.prototype에 includes 메서드가 추가되었습니다.
ECMAScript 2017은 Async 함수, 공유 메모리, Atomics, 그리고 더 작은 언어 및 라이브러리 개선, 버그 수정, 편집 업데이트를 도입했습니다. Async 함수는
프라미스를 반환하는 함수에 대한 문법을 제공하여 비동기 프로그래밍 경험을 향상시킵니다. 공유 메모리와 Atomics는 병렬 CPU에서도 명확한 실행 순서를 보장하는 원자적 연산을 사용하여
다중 에이전트 프로그램이 통신할 수 있는 새로운
메모리 모델을
도입했습니다. 또한 객체에 대한 새로운 정적 메서드인 Object.values, Object.entries,
Object.getOwnPropertyDescriptors도 포함되었습니다.
ECMAScript 2018은 비동기 이터레이터 프로토콜과 async 제너레이터를 통해 비동기 반복 지원을
도입했습니다. 또한 네 가지 새로운 정규식 기능(dotAll 플래그, 명명된 캡처 그룹, 유니코드 속성 이스케이프, 그리고 look-behind 어설션)과 객체의 rest 및 spread
속성을 추가했습니다.
ECMAScript 2019는 Array.prototype의 flat 및 flatMap 함수를 통한 배열 평탄화,
Object.entries의 반환값을 새 객체로 바로 변환하는 Object.fromEntries, 더 나은 이름의
String.prototype.trimStart 및 trimEnd 내장 함수(기존 비표준 trimLeft,
trimRight 대체용) 등 몇 가지 새로운 내장 함수를 도입했습니다. 또한 문법 및 의미론에 대한 소규모 업데이트(선택적 catch 바인딩 파라미터, JSON과
일치시키기 위해 문자열 리터럴에서 U+2028 및 U+2029 허용 등)가 포함되었습니다. 기타 업데이트에는 Array.prototype.sort의 안정적 정렬
요구, JSON.stringify의 입력에 상관없이 올바른 UTF-8 반환 요구, Function.prototype.toString의
명확화(원본 소스 텍스트 또는 표준 플레이스홀더 반환 요구)가 있습니다.
ECMAScript 2020, 11번째 에디션은 문자열의 matchAll 메서드(글로벌 정규식으로 생성된 모든 매치 객체에 대한 이터레이터
생성), import() 문법(동적 지정자로 모듈을 비동기적으로 import), BigInt(임의 정밀도의 정수를 다루는 새로운 숫자 원시 타입),
Promise.allSettled(짧은 회로 없음), globalThis(글로벌 this 값 접근의 범용 방법),
모듈 내 export * as ns from 'module' 문법, for-in 열거 순서의 표준화 강화, 모듈 내에서 컨텍스트 정보를 담을
수 있는 import.meta 객체, nullish 값(undefined 또는 null)을
다루기 위한 새로운 문법(nullish 병합 연산자, 옵셔널 체이닝 연산자) 등을 도입했습니다.
ECMAScript 2021, 12번째 에디션은 문자열의 replaceAll 메서드, Promise.any(입력값이
fulfill될 때 짧은 회로), AggregateError(여러 오류를 한 번에 표현하는 새로운 오류 타입), 논리 할당 연산자(??=,
&&=, ||=), WeakRef(가비지 컬렉션에서 객체를 보존하지 않고 참조),
FinalizationRegistry(가비지 컬렉션 시 정리 작업 등록 및 해제 관리), 숫자 리터럴 구분자(1_000),
Array.prototype.sort의 구현 정의 정렬 순서정렬 순서의 경우 감소 등 다양한 기능을 도입했습니다.
ECMAScript 2022, 13번째 에디션은 모듈의 최상위에서 await 사용을 허용하는 기능, 클래스 내의 새로운 요소(퍼블릭 및 프라이빗
인스턴스 필드, 퍼블릭 및 프라이빗 정적 필드, 프라이빗 인스턴스 메서드 및 접근자, 프라이빗 정적 메서드 및 접근자), 클래스 내 정적 블록(클래스별 평가 초기화 수행),
#x in obj 문법(객체에 프라이빗 필드 존재 여부 테스트), /d 플래그(정규식 매치 인덱스 제공), Error
객체의 cause 속성(에러의 원인 연쇄 기록), 문자열, 배열, TypedArray의 at 메서드(상대 인덱싱 지원),
Object.hasOwn(Object.prototype.hasOwnProperty의 편리한 대안) 등을 도입했습니다.
ECMAScript 2023, 14번째 에디션은 Array.prototype 및 TypedArray.prototype에
toSorted, toReversed, with, findLast,
findLastIndex 메서드, Array.prototype의 toSpliced 메서드, 파일 시작 부분에
#! 주석 지원(실행 가능한 ECMAScript 파일 지원 향상), 대부분의 심볼을 weak 컬렉션의 키로 사용 가능 등 기능을 도입했습니다.
ECMAScript 2024, 15번째 에디션은 ArrayBuffer 및 SharedArrayBuffer의 리사이즈 및 전송 기능, 문자열 집합 작업을 위한 고급 기능의
새로운 RegExp /v 플래그, Promise 생성 편의 메서드 Promise.withResolvers, 데이터 집계용
Object.groupBy 및 Map.groupBy 메서드, 공유 메모리 변경을 비동기적으로 대기하는
Atomics.waitAsync 메서드, 문자열의 올바른 유니코드만 포함되는지 검사 및 보장하는
String.prototype.isWellFormed 및 String.prototype.toWellFormed 메서드 등을 도입했습니다.
ECMAScript 2025, 16번째 에디션은 이터레이터 작업을 위한 새로운 Iterator 글로벌과 관련 정적
및 프로토타입 메서드, Set.prototype의 일반적 셋 연산 메서드, JSON 모듈 import 및 import된 모듈의 속성 선언 문법, 정규식 내 안전한
문자열 사용을 위한 RegExp.escape 메서드, 정규식 내에서 인라인으로 modifier 플래그 활성/비활성화 문법, 함수의 반환값이 프라미스일 수도 아닐
수도 있을 때 항상 프라미스로 반환하는 Promise.try 메서드, 새로운 Float16ArrayTypedArray 종류와 관련
DataView.prototype.getFloat16, DataView.prototype.setFloat16,
Math.f16round 메서드를 도입했습니다.
Ecma TC39 내에서 많은 조직을 대표하는 수십 명의 개인이 이 에디션과 이전 에디션의 개발에 매우 중요한 기여를 했습니다. 또한 TC39의 ECMAScript 작업을 지원하는 활발한
커뮤니티가 생겨났습니다. 이 커뮤니티는 수많은 초안 검토, 수천 건의 버그 리포트 제출, 구현 실험, 테스트 스위트 기여, ECMAScript에 대한 전 세계 개발자 교육 등 다양한
활동을 했습니다. 모든 기여자와 조직을 식별하고 인정하는 것은 불가능합니다.
Allen Wirfs-Brock
ECMA-262, 프로젝트 에디터, 6번째 에디션
Brian Terlson
ECMA-262, 프로젝트 에디터, 7번째 ~ 10번째 에디션
Jordan Harband
ECMA-262, 프로젝트 에디터, 10번째 ~ 12번째 에디션
Shu-yu Guo
ECMA-262, 프로젝트 에디터, 12번째 ~ 16번째 에디션
Michael Ficarra
ECMA-262, 프로젝트 에디터, 12번째 ~ 16번째 에디션
Kevin Gibbons
ECMA-262, 프로젝트 에디터, 12번째 ~ 16번째 에디션
1 범위
이 표준은 ECMAScript 2026 범용 프로그래밍 언어를 정의합니다.
2 준수
ECMAScript의 준수 구현체는 이 명세서에 기술된 모든 타입, 값, 객체, 프로퍼티, 함수, 프로그램 구문 및 의미론을 제공하고 지원해야 합니다.
ECMAScript의 준수 구현체는 소스 텍스트 입력을 최신 버전의 유니코드 표준 및 ISO/IEC 10646에 따라 해석해야 합니다.
다양한 인간 언어와 국가에서 사용되는 언어적, 문화적 관습에 적응이 필요한 프로그램을 지원하는 API를 제공하는 ECMAScript의 준수 구현체는 이 명세서와 호환되는 ECMA-402의
최신판에서 정의된 인터페이스를 구현해야 합니다.
ECMAScript의 준수 구현체는 이 명세서에 기술된 것 이외의 추가 타입, 값, 객체, 프로퍼티, 함수 등을 제공할 수 있습니다. 특히, 준수 구현체는 명세서에 기술되지 않은 프로퍼티와
그 값, 그리고 명세서에 기술된 객체에 대해 추가 프로퍼티를 제공할 수 있습니다.
ECMAScript의 준수 구현체는 이 명세서에 기술되지 않은 프로그램 및 정규식 구문을 지원할 수 있습니다. 특히, 준수 구현체는 이 명세서의 예약어로 지정된 “미래 12.7.2”를 사용하는 프로그램 구문을 지원할 수 있습니다.
ECMAScript의 준수 구현체는 17.1절에서 금지 확장으로 명시된 어떤 확장도 구현해서는 안 됩니다.
ECMAScript의 준수 구현체는 구현 정의, 구현
근사, 또는 호스트
정의가 아닌 어떤 기능도 재정의해서는 안 됩니다.
ECMAScript의 준수 구현체는 규범적 선택 사항 절을 구현할지 말지 선택할 수 있습니다. 어떤 규범적 선택 사항 동작을 구현하는 경우,
해당 규범적 선택 사항 절의 모든 동작을 구현해야 합니다. 규범적 선택 사항 절은 아래와 같이 색상 박스에 “Normative Optional”이라는 단어로 표시됩니다.
ECMAScript의 준수 구현체는 규범적 선택 사항으로도 표시되지 않는 레거시 절을 반드시 구현해야 합니다. 레거시 절 내에 명시된 모든 언어
기능과 동작은 하나 이상의 바람직하지 않은 특성을 가지고 있습니다. 그러나 기존 애플리케이션에서 계속 사용되고 있기 때문에 이 명세서에서 제거할 수 없습니다. 이러한 기능은
ECMAScript 언어의 핵심에 해당하지 않습니다. 새로운 ECMAScript 코드를 작성할 때 프로그래머는 이러한 기능과 동작을 사용하거나 존재를 가정해서는 안 됩니다.
ECMAScript는 호스트
환경 내에서 계산을 수행하고 계산 객체를 조작하기 위한 객체 지향 프로그래밍 언어입니다. 여기서 정의된 ECMAScript는 계산적으로
자급자족하는 것을 목표로 하지 않습니다. 실제로, 이 명세에는 외부 데이터 입력이나 계산 결과 출력을 위한 규정이 없습니다. 대신, ECMAScript 프로그램의 계산 환경은 이 명세에
설명된 객체 및 기타 기능뿐만 아니라, 환경별 객체도 제공할 것으로 예상되며, 이러한 객체의 설명과 동작은 이 명세의 범위를 벗어나지만 특정 속성에 접근하거나 ECMAScript
프로그램에서 호출할 수 있는 함수가 있을 수 있음을 나타냅니다.
ECMAScript는 원래 스크립트 언어로 설계되었으나, 현재는 범용 프로그래밍 언어로 널리 사용되고 있습니다. 스크립트 언어는 기존 시스템의 기능을 조작, 사용자화,
자동화하는 데 사용되는 프로그래밍 언어입니다. 이러한 시스템에서는 이미 유용한 기능이 사용자 인터페이스를 통해 제공되고, 스크립트 언어는 해당 기능을 프로그램 제어로 노출하는 수단입니다.
이렇게 기존 시스템이 호스트
환경의 객체와 기능을 제공하여 스크립트 언어의 역량을 완성합니다. 스크립트 언어는 전문가와 비전문가 모두 사용할 수 있도록 설계되었습니다.
ECMAScript는 원래 웹 스크립트 언어로 설계되어 브라우저에서 웹 페이지에 생동감을 부여하거나 웹 기반 클라이언트-서버 구조에서 서버 계산을 수행하는 메커니즘을
제공했습니다. ECMAScript는 이제 다양한 호스트 환경에서 핵심 스크립트 기능을 제공합니다. 따라서 핵심 언어는 특정 호스트 환경과 별도로 이
문서에서 명세됩니다.
ECMAScript의 사용은 단순 스크립트에서 벗어나 현재는 여러 환경과 규모에서 모든 프로그래밍 작업에 사용됩니다. ECMAScript의 사용이 확장됨에 따라 제공하는 기능과 설비도
확장되었습니다. ECMAScript는 이제 완전한 범용 프로그래밍 언어입니다.
4.1 웹 스크립팅
웹 브라우저는 클라이언트 측 계산을 위한 ECMAScript 호스트 환경을 제공합니다. 여기에는 예를 들어, 창, 메뉴, 팝업, 대화 상자, 텍스트 영역,
앵커, 프레임, 히스토리, 쿠키, 입출력을 나타내는 객체 등이 포함됩니다. 또한 호스트 환경은 포커스 변경, 페이지 및 이미지 로딩, 언로드, 오류 및 중단, 선택, 폼
제출, 마우스 동작 등 이벤트에 스크립트 코드를 연결하는 방법을 제공합니다. 스크립트 코드는 HTML 내에 나타나며, 표시되는 페이지는 사용자 인터페이스 요소와 고정 및 계산된
텍스트 및 이미지의 조합입니다. 스크립트 코드는 사용자 상호작용에 반응하며, 메인 프로그램이 필요하지 않습니다.
웹 서버는 요청, 클라이언트, 파일을 나타내는 객체, 데이터 잠금 및 공유 메커니즘 등 서버 측 계산을 위한 별도의 호스트 환경을 제공합니다. 브라우저 측과 서버 측 스크립팅을 함께
사용하면, 사용자 맞춤형 웹 애플리케이션에서 클라이언트와 서버 간에 계산을 분산시킬 수 있습니다.
ECMAScript를 지원하는 각 웹 브라우저와 서버는 자체 호스트 환경을 제공하여 ECMAScript 실행 환경을 완성합니다.
4.2 호스트와 구현체
호스트 환경에
ECMAScript 통합을 돕기 위해, 이 명세는 특정 기능(예: 추상 연산)의
정의를 전체 또는 일부 외부 소스에 위임합니다. 편집상, 이 명세는 다음과 같은 위임 유형을 구분합니다.
구현체는 부록 D에 열거된 기능이나 구현
정의 또는 구현 근사로 표시된 기능을 외부에서 추가 정의하는 소스입니다.
비공식적으로, 구현체는 특정 웹 브라우저와 같은 구체적인 산출물을 의미합니다.
구현 정의 기능은 추가적인 자격 없이 정의를 외부 소스에 위임하는 기능입니다. 이
명세는 특정 동작에 대한 권고를 하지 않으며, 준수 구현체는 이 명세가 제시하는 제약 내에서 어떤 동작이든 자유롭게 선택할 수 있습니다.
구현 근사 기능은 이상적인 동작을 권고하면서 정의를 외부 소스에 위임하는
기능입니다. 준수 구현체는 이 명세가 제시하는 제약 내에서 어떤 동작이든 자유롭게 선택할 수 있지만, 이상적인 동작에 근접하도록 노력해야 합니다. Math.exp와
같은 일부 수학 연산은 구현 근사에 해당합니다.
호스트는 부록 D에 열거된 기능을 추가 정의하지만, 그 외의 구현
정의 또는 구현 근사 기능은 추가 정의하지 않는 외부 소스입니다. 비공식적으로,
호스트는 부록 D를 통해 이 명세와 같은 방식으로 연결되는 모든 구현체 집합(모든 웹 브라우저
집합 등)을 의미합니다. 호스트는 종종 WHATWG
HTML(https://html.spec.whatwg.org/)과 같은 외부 명세입니다. 즉,
호스트 정의 기능은 종종
외부 명세에서 추가로 정의됩니다.
호스트 후크는 전체 또는 일부가 외부 소스에 의해 정의되는 추상
연산입니다. 모든 호스트 후크는 부록
D에 나열되어야 합니다. 호스트 후크는 최소한 다음 요구사항을 충족해야 합니다:
호스트 정의 기능은 추가적인 자격 없이 정의를 외부 소스에 위임하며, 부록 D에 나열되어야 합니다. 호스트가 아닌 구현체도 호스트 정의 기능에 대한 정의를 제공할 수 있습니다.
호스트 환경은 모든 호스트 정의 기능에 대한 구체적 정의
선택입니다. 호스트
환경에는 일반적으로 호스트 정의 속성으로 입력을 얻거나 출력을 제공하는 객체 또는 함수가 포함되고, 이는
글로벌
객체에 속합니다.
이 명세는 항상 가장 구체적인 용어를 사용하는 편집 관례를 따릅니다. 예를 들어, 어떤 기능이 호스트 정의라면, 구현 정의로 언급해서는 안 됩니다.
호스트와 구현체 모두 이 명세가 정의한 언어 타입, 명세
타입, 추상 연산, 문법 생성규칙, 내장 객체,
내장 심볼을 통해 이 명세와 인터페이스할 수 있습니다.
4.3 ECMAScript 개요
다음은 ECMAScript에 대한 비공식적 개요입니다. 언어의 모든 부분이 설명된 것은 아니며, 이 개요는 표준의 일부가 아닙니다.
ECMAScript는 객체 기반입니다. 기본 언어 및 호스트 기능이 객체로 제공되며, ECMAScript 프로그램은 서로 통신하는 객체 집합입니다.
ECMAScript에서 객체는 0개 이상의 프로퍼티로 이루어진 컬렉션이며, 각 프로퍼티는 해당 프로퍼티의 사용 방식을 결정하는
속성을 가집니다. 예를 들어, 프로퍼티의 Writable 속성이 false로 설정된 경우, ECMAScript 코드가 해당
프로퍼티에 다른 값을 할당하려는 모든 시도는 실패합니다. 프로퍼티는 다른 객체, 프리미티브 값, 또는 함수를 저장하는 컨테이너입니다. 프리미티브
값은 다음 내장 타입 중 하나에 속합니다: Undefined, Null, Boolean, Number, BigInt,
String, Symbol; 객체는 내장 타입 Object에 속하며, 함수는 호출 가능한 객체입니다. 객체에 프로퍼티로 연결된 함수를
메서드라고 합니다.
ECMAScript는 ECMAScript 엔티티 정의를 완성하는 내장 객체 집합도 정의합니다. 이러한 내장 객체에는 글로벌 객체, 언어의
런타임
의미론에 기본적인 객체들(Object, Function, Boolean, Symbol, 다양한 Error 객체), 숫자 값을 나타내고
조작하는 객체들(Math, Number, Date), 텍스트 처리 객체(String, RegExp), 값이 인덱스된 컬렉션(Array 및 9종의 Typed Array), 키 기반
컬렉션(Map, Set 객체), 구조화된 데이터 지원(JSON 객체, ArrayBuffer, SharedArrayBuffer, DataView), 제어 추상화를 지원하는
객체(제너레이터 함수, Promise 객체), 그리고 반영 객체(Proxy, Reflect)가 포함됩니다.
ECMAScript는 내장 연산자 집합도 정의합니다. ECMAScript 연산자에는 다양한 단항 연산, 곱셈 연산자, 덧셈 연산자, 비트 시프트 연산자, 관계
연산자, 동등성 연산자, 이진 비트 연산자, 이진 논리 연산자, 할당 연산자, 쉼표 연산자가 포함됩니다.
대규모 ECMAScript 프로그램은 모듈을 통해 지원되며, 프로그램을 여러 문(statement) 및 선언(declaration) 시퀀스로 분할할 수 있습니다. 각
모듈은 다른 모듈에서 제공되어야 할 선언과, 다른 모듈에서 사용할 수 있는 자신의 선언을 명시적으로 식별합니다.
ECMAScript 문법은 의도적으로 Java 문법과 유사하게 설계되었습니다. ECMAScript 문법은 쉽게 사용할 수 있는 스크립트 언어가 되도록 완화되어 있습니다. 예를 들어,
변수는 타입 선언이 필요하지 않으며, 프로퍼티에 타입이 연결되지 않고, 정의된 함수도 호출보다 먼저 선언될 필요가 없습니다.
4.3.1 객체
ECMAScript에는 클래스 정의 구문이 포함되어 있지만, ECMAScript 객체는 C++, Smalltalk, Java와 같은 언어의 객체처럼 근본적으로 클래스 기반이
아닙니다. 대신, 객체는 리터럴 표기법이나 생성자를 통해 여러 방식으로 생성될 수 있으며, 생성자는 객체를 생성한 후 초기
값을 프로퍼티에 할당하여 객체 전체 또는 일부를 초기화하는 코드를 실행합니다. 각 생성자는 "prototype"이라는 프로퍼티를 가지는 함수로,
프로토타입 기반 상속 및 공유 프로퍼티를 구현합니다. 객체는 new 표현식에서 생성자를 사용하여 생성됩니다. 예를
들어, new Date(2009, 11)은 새로운 Date 객체를 생성합니다. new 없이 생성자를 호출하면, 그 결과는
생성자에 따라 다릅니다.
예를 들어, Date()는 객체가 아니라 현재 날짜와 시간의 문자열 표현을 반환합니다.
생성자로 생성된 모든
객체는 암시적 참조(객체의 프로토타입이라 함)를 가지며, 이는 해당 생성자의 "prototype" 프로퍼티 값입니다. 또한,
프로토타입은 자신의 프로토타입에 대한 null이 아닌 암시적 참조를 가질 수 있습니다. 이를 프로토타입 체인이라고 합니다.
객체의 프로퍼티에 대한 참조가 이루어지면, 해당 참조는 프로토타입 체인에서 그 이름의 프로퍼티를 가진 첫 번째 객체의 프로퍼티에 대한 참조입니다. 즉, 먼저 직접 언급된
객체에서 프로퍼티를 찾고, 해당 객체에 프로퍼티가 있으면 그 프로퍼티를 참조하며, 없다면 그 객체의 프로토타입을 다음으로 검사합니다.
그림 1: 객체/프로토타입 관계
클래스 기반 객체 지향 언어에서는 일반적으로 상태는 인스턴스가, 메서드는 클래스가 가지며, 상속은 구조와 동작에만 적용됩니다. ECMAScript에서는 상태와 메서드가 객체에
포함되며, 구조, 동작, 상태 모두 상속됩니다.
프로토타입에 특정 프로퍼티가 있지만 직접 해당 프로퍼티를 가지지 않는 모든 객체는 그 프로퍼티와 값을 공유합니다. 그림 1은 이를 보여줍니다:
CF는 생성자(그리고 객체)입니다. new 표현식을 통해 5개 객체가 생성되었습니다:
cf1,
cf2, cf3, cf4, cf5.
각 객체는 "q1" 및 "q2"라는 프로퍼티를 가집니다. 점선은 암시적 프로토타입 관계를 나타냅니다.
예를 들어, cf3의 프로토타입은 CFp입니다. 생성자CF는 두 개의
프로퍼티("P1", "P2")를 가지지만, CFp,
cf1, cf2, cf3, cf4,
cf5에서는 볼 수 없습니다. CFp의 "CFP1" 프로퍼티는
cf1, cf2, cf3, cf4,
cf5에서 공유되며(CF에서는 공유되지 않음), CFp의 암시적 프로토타입 체인에서
"q1", "q2", "CFP1"이 아닌 다른 프로퍼티도 마찬가지로
공유됩니다. CF와 CFp 사이에는 암시적 프로토타입 링크가 없습니다.
대부분의 클래스 기반 객체 언어와 달리, 객체에는 값을 할당하여 동적으로 프로퍼티를 추가할 수 있습니다. 즉, 생성자는 생성된 객체의 모든 프로퍼티를 반드시 명명하거나 값을 할당할
필요가 없습니다. 위 다이어그램에서 cf1, cf2, cf3,
cf4, cf5에 대해 CFp에 새 값을 할당하여 새로운 공유 프로퍼티를
추가할 수 있습니다.
ECMAScript 객체는 본질적으로 클래스 기반은 아니지만, 공통된 생성자 함수, 프로토타입 객체, 메서드 패턴에 기반하여 클래스와 유사한 추상화를 정의하는 것이
편리한 경우가 많습니다. ECMAScript 내장 객체 자체도 이러한 클래스와 유사한 패턴을 따릅니다. ECMAScript 2015부터 ECMAScript 언어에는 내장
객체가 사용하는 클래스와 유사한 추상화 패턴에 맞는 객체를 간결하게 정의할 수 있는 문법적 클래스 정의가 포함되어 있습니다.
4.3.2 ECMAScript의 엄격 변형(strict variant)
ECMAScript 언어는 일부 사용자가 언어의 일부 기능 사용을 제한하고자 할 수도 있음을 인식합니다. 이는 보안, 오류 발생 가능성이 높은 기능 회피, 향상된 오류 검사,
기타 이유 등으로 이루어질 수 있습니다. 이를 지원하기 위해, ECMAScript는 엄격 변형(strict variant)을 정의합니다. 엄격 변형은 일반
ECMAScript 언어의 일부 구문적·의미론적 기능을 제외하고, 일부 기능의 상세 의미론을 수정합니다. 엄격 변형에서는 비엄격(non-strict) 언어 형태에서는 오류로
지정되지 않은 상황에서도 오류 예외를 던져야 하는 추가 오류 조건도 지정합니다.
ECMAScript의 엄격 변형은 일반적으로 언어의 엄격 모드(strict mode)라고 불립니다. 엄격 모드 선택 및 엄격 모드 구문과 의미론 사용은
ECMAScript 소스
텍스트 단위 수준에서 명시적으로 이루어지며, 이는 11.2.2에서 설명되어 있습니다. 엄격 모드는 구문 소스
텍스트 단위 수준에서 선택되므로, 엄격 모드는 해당 소스 텍스트 단위 내에서만 국지적으로 적용되는 제한을 부과합니다. 엄격 모드는 여러 소스 텍스트 단위에 걸쳐 일관되게
동작해야 하는 ECMAScript 의미론의 어떤 측면도 제한하거나 수정하지 않습니다. 완전한 ECMAScript 프로그램은 엄격 모드 및 비엄격 모드 ECMAScript 소스
텍스트 단위를 모두 포함할 수 있습니다. 이 경우, 실제로 엄격 모드 소스 텍스트 단위 내에서 정의된 코드를 실행할 때만 엄격
모드가 적용됩니다.
이 명세를 준수하려면, ECMAScript 구현체는 이 명세에서 정의된 전체 제한 없는 ECMAScript 언어와 엄격 변형 ECMAScript 언어를 모두 구현해야 합니다.
또한, 구현체는 제한 없는 소스 텍스트 단위와 엄격 모드 소스 텍스트 단위를 하나의 복합 프로그램으로 결합하는 것도 지원해야 합니다.
constructor의 "prototype"
프로퍼티 값은 상속과 공유 프로퍼티를 구현하는 프로토타입 객체입니다.
4.4.8 prototype
다른 객체에 공유 프로퍼티를 제공하는 객체
참고
constructor가 객체를 생성하면, 그 객체는 프로퍼티 참조를 해결하기 위해
constructor의 "prototype"
프로퍼티를 암시적으로 참조합니다. constructor의 "prototype"
프로퍼티는 프로그램 표현식 constructor.prototype으로 참조할 수 있습니다. 객체의 프로토타입에
프로퍼티를 추가하면, 그 프로토타입을 공유하는 모든 객체가 상속을 통해 해당 프로퍼티를 공유합니다. 또는, Object.create
내장 함수를 사용하여 명시적으로 지정된 프로토타입으로 새 객체를 생성할 수도 있습니다.
Boolean 객체는 new 표현식에서 Boolean 생성자를 사용하여 Boolean 값을 인자로 전달하여
생성됩니다. 결과 객체는 Boolean 값을 가지는 내부 슬롯을 갖습니다. Boolean 객체는 Boolean 값으로 강제 변환될 수 있습니다.
4.4.20 String value
finite 16비트 부호 없는
integer 값의 0개 이상의 순서
있는 시퀀스인 프리미티브 값
참고
문자열 값은 String type의
멤버입니다. 시퀀스 내 각 integer 값은 일반적으로 UTF-16 텍스트의 16비트 단위를 나타냅니다. 그러나
ECMAScript는 값에 대해 16비트 부호 없는 integer이어야 한다는 것 외에는 제한이나 요구사항을 두지 않습니다.
문자열 객체는 new 표현식에서 String 생성자를 사용하여 문자열 값을 인자로 전달하여 생성됩니다. 결과 객체는 문자열
값을 가지는 내부 슬롯을 갖습니다. 문자열 객체는 String 생성자를 함수로 호출하여 문자열 값으로 강제 변환할 수 있습니다
(22.1.1.1).
Number 객체는 new 표현식에서 Number 생성자를 사용하여 숫자 값을 인자로 전달하여 생성됩니다. 결과 객체는 숫자 값을
가지는 내부 슬롯을 갖습니다. Number 객체는 Number 생성자를 함수로 호출하여 숫자 값으로 강제 변환할 수 있습니다 (21.1.1.1).
11절부터 17절까지는 모든 언어 기능의 구문적 인코딩과
실행 의미론을 포함하여 실제 ECMAScript 프로그래밍 언어를 정의합니다.
18절부터 28절까지는 ECMAScript
표준 라이브러리를 정의합니다. 여기에는 ECMAScript 프로그램이 실행 시 사용할 수 있는 모든 표준 객체의 정의가 포함됩니다.
29절에서는
SharedArrayBuffer 기반 메모리의 접근 및 Atomics 객체 메서드의 메모리 일관성 모델을 설명합니다.
5 표기 규칙
5.1 구문 및 렉시컬 문법
5.1.1 문맥 자유 문법
문맥 자유 문법은 여러 개의 생산으로 구성됩니다. 각 생산은 비단말 기호라는 추상적인 기호를 왼쪽에 가지고,
0개 이상의 비단말 및 단말 기호를 오른쪽에 나열합니다. 각 문법에서 단말 기호는 지정된 알파벳에서 가져옵니다.
연쇄 생산이란 오른쪽에 정확히 하나의 비단말 기호와 0개 이상의 단말 기호만을
가지는 생산을 말합니다.
특정 문맥 자유 문법은 목표 기호라 불리는 하나의 구별된 비단말로 구성된 문장에서
시작하여, 시퀀스 내의 아무 비단말이나 그 비단말이 왼쪽이 되는 생산의 오른쪽으로 반복적으로 대체함으로써 결과적으로 생성할 수 있는 단말 기호의 모든 가능한 시퀀스
집합(언어)을 지정합니다. 이 집합은 유한하거나 무한할 수 있습니다.
공백 문자와 주석을 제외한 입력 요소는 ECMAScript의 구문 문법의 단말 기호가 되며, 이를 ECMAScript 토큰이라 부릅니다. 이 토큰들은
예약어, 식별자, 리터럴, ECMAScript 언어의
구분자입니다. 또한, 줄 종결자는 토큰으로 간주되지 않지만 입력 요소 스트림의 일부가 되어 자동 세미콜론 삽입 과정(12.10)을 안내합니다. 단순 공백 및 한 줄 주석은
버려지며, 구문 문법을 위한 입력 요소 스트림에는 나타나지 않습니다. MultiLineComment(즉, 여러 줄에 걸쳐 있을 수 있는
/*…*/ 형태의 주석)는 줄 종결자가 없으면 단순히 버려집니다. 그러나 MultiLineComment가 하나 이상의 줄 종결자를 포함하는 경우, 단일 줄
종결자로 대체되어 구문 문법을 위한 입력 요소 스트림의 일부가 됩니다.
ECMAScript의 정규식 문법은 22.2.1에 제공됩니다. 이 문법 역시 SourceCharacter로 정의된 코드 포인트를 단말 기호로 사용합니다. 이
문법은 목표 기호Pattern에서 시작하여, 코드 포인트 시퀀스가 정규식 패턴으로 변환되는 방법을 설명합니다.
렉시컬 및 정규식 문법의 생산은 구분 기호로 두 개의 콜론 “::”을 사용하여 구분됩니다. 렉시컬 문법과 정규식 문법은 일부 생산을 공유합니다.
숫자 문자열 문법의 생산은 세 개의 콜론 “:::”으로 구분되며, 소스 텍스트 파싱에는 절대 사용되지 않습니다.
5.1.4 구문 문법
ECMAScript의 구문 문법은 13부터 16까지의 절에 제공됩니다. 이 문법은
렉시컬 문법에서 정의된 ECMAScript 토큰을 단말 기호로 사용합니다(5.1.2). 목표
기호Script와
Module에서 시작하여, 토큰 시퀀스가 ECMAScript
프로그램의 구문적으로 올바른 독립 구성 요소를 형성하는 방법을 설명합니다.
코드 포인트 스트림을 ECMAScript Script 또는
Module로 파싱할 때, 먼저 렉시컬 문법을 반복적으로 적용하여
입력 요소 스트림으로 변환합니다. 그 후 이 입력 요소 스트림을 단일 구문 문법 적용으로 파싱합니다. 입력 스트림의 토큰들이 목표 비단말(Script 또는 Module)의 단일 인스턴스로 파싱될 수 없거나 토큰이 남아 있다면 구문 오류입니다.
파싱에 성공하면, 파싱 트리라는 루트가 있는 트리 구조를 생성합니다. 각 노드는 파싱 노드입니다. 각 파싱 노드는 문법 기호의 인스턴스이며, 해당 기호로부터 유도될 수 있는 소스 텍스트의 범위를
나타냅니다. 파싱 트리의 루트 노드(소스 텍스트 전체를 나타냄)는 파싱의 목표 기호의 인스턴스입니다. 파싱 노드가
비단말의 인스턴스인 경우, 그 비단말을 왼쪽으로 하는 생산의 인스턴스이기도 합니다. 또한, 오른쪽에 있는 각 기호마다 0개 이상의 자식을 가지며, 각 자식은
해당 기호의 파싱 노드 인스턴스입니다.
새로운 파싱 노드는 파서 호출마다 인스턴스화되며 동일한 소스 텍스트라도 파싱 간에는 재사용되지 않습니다. 파싱 노드는 동일한 소스 텍스트 범위를 나타내고, 동일한 문법 기호의
인스턴스이며, 동일한 파서 호출에서 생성된 경우에만 동일한 파싱 노드로 간주됩니다.
참고 1
동일한 문자열을 여러 번 파싱하면 서로 다른 파싱 노드가 생성됩니다. 예를 들어,
let str = "1 + 1;";
eval(str);
eval(str);
각 eval 호출은 str의 값을 ECMAScript 소스 텍스트로 변환하고, 각기
독립적으로 파싱하여 별도의 파싱 노드 트리를 생성합니다. 각 파싱은 동일한 문자열 값에서 유래했더라도 트리는 서로 다릅니다.
참고 2
파싱 노드는 명세상의 산물이며, 구현체는 유사한 데이터 구조를 사용할 필요는 없습니다.
구문 문법의 생산은 구분 기호로 하나의 콜론 “:”만을 사용합니다.
13부터 16까지 제시된 구문 문법은
ECMAScript Script 또는 Module에 대해 허용되는 토큰 시퀀스의 완전한 설명이 아닙니다. 특정
추가 토큰 시퀀스도 허용되는데, 이는 특정 위치(예: 줄 종결자 앞)에 세미콜론만 추가하면 문법에서 설명될 수 있는 시퀀스입니다. 또한, 문법에서 설명된 일부 토큰 시퀀스는
특정 “어색한” 위치에 줄 종결자가 나타나면 허용되지 않습니다.
특정 경우, 모호성을 피하기 위해 구문 문법은 유효한 ECMAScript Script 또는 Module를 형성하지 않는 토큰 시퀀스도 허용하는 일반화된 생산을 사용합니다. 예를 들어, 객체
리터럴 및 객체 구조 분해 패턴에서 이 기법이 사용됩니다. 이러한 경우, 허용되는 토큰 시퀀스를 더욱 제한하는 보조 문법이 제공됩니다. 일반적으로
조기 오류 규칙은 특정
문맥에서 "P는 N을 포함해야 한다"라고 명시합니다. 여기서
P는 일반화된 생산의 파싱 노드 인스턴스이며 N은 보조 문법의 비단말입니다. 이는 다음을 의미합니다:
P가 원래 매칭한 토큰 시퀀스를 N을 목표 기호로 하여 다시 파싱합니다.
N이 문법 파라미터를 가지면, P가 원래 파싱될 때와 동일한 값으로 설정합니다.
토큰 시퀀스가 N의 단일 인스턴스로 파싱될 수 있고, 토큰이 남지 않으면:
해당 P에 대해 고유한 N 인스턴스를 "P가 포함하는
N”이라고 부릅니다.
N 및 그 파생 생산에 대한 모든 조기 오류 규칙은 P가 포함하는 N에도 적용됩니다.
그렇지 않으면(파싱이 실패하면) 조기 문법 오류입니다.
5.1.5 문법 표기법
5.1.5.1 단말 기호
ECMAScript 문법에서 일부 단말 기호는 고정폭 글꼴로 표시됩니다.
이러한 기호는 소스 텍스트에 정확히 작성된 대로 나타나야 합니다. 이 방식으로 지정된 모든 단말 기호 코드 포인트는 기본 라틴 블록의 적절한 Unicode 코드
포인트로 이해되어야 하며, 다른 Unicode 범위의 유사한 코드 포인트와는 다릅니다.
단말 기호의 코드 포인트는 \UnicodeEscapeSequence로 표현할 수 없습니다.
단말 기호가 개별 Unicode 코드 포인트인 문법(즉, 렉시컬, 정규식, 숫자 문자열 문법)에서, 생산 내 여러 고정폭 코드 포인트가 연속적으로 나타나는 것은 동일한
시퀀스의 코드 포인트를 각각 독립된 단말 기호로 작성하는 것에 대한 간단한 약어입니다.
반대로, 구문 문법에서는 고정폭 코드 포인트가 연속적으로 나타나면 하나의 단일 단말 기호입니다.
단말 기호는 다음 두 가지 형태도 있습니다:
렉시컬 및 정규식 문법에서는 일반적으로 인쇄되는 표현이 없는 Unicode 코드 포인트가 대신 "<ABBREV>" 형태로 표시되며,
"ABBREV"는 해당 코드 포인트 또는 코드 포인트 집합을 위한 기억법입니다. 이러한 형태는 유니코드 포맷-컨트롤 문자,
공백
문자, 줄 종결자에서 정의됩니다.
비단말 기호는 이탤릭체로 표시됩니다. 비단말의 정의(생산이라고도 함)는 정의되는 비단말의 이름 뒤에 하나 이상의 콜론이 붙어 도입됩니다. (콜론의 개수는
해당 생산이 속하는 문법을 나타냅니다.) 비단말의 하나 이상의 대체 오른쪽 부분이 뒤따라 나열됩니다. 예를 들어, 구문 정의는 다음과 같습니다:
즉, 이 예시에서 ForStatement 비단말은 실제로 네 가지
대안 오른쪽을 가집니다.
5.1.5.4 문법 파라미터
생산은 아래첨자 주석 "[parameters]" 형태로 파라미터화될 수 있으며, 이는 생산에서 정의된 비단말 기호의 접미사로 나타날 수 있습니다.
“parameters”는 하나의 이름 또는 쉼표로 구분된 이름 목록일 수 있습니다. 파라미터화된 생산은 해당 파라미터 이름의 모든 조합에 대한
생산 집합을 나타내는 약어로, 파라미터화된 비단말 기호 뒤에 언더스코어와 함께 붙여집니다. 이는 다음을 의미합니다:
오른쪽 대안에 “[+parameter]”가 접두사로 붙으면, 해당 대안은 지정된 파라미터가 생산의 비단말 기호 참조에 사용될 때만 사용할 수 있습니다.
“[~parameter]”가 접두사로 붙으면, 해당 대안은 지정된 파라미터가 사용되지 않을 때만 사용할 수 있습니다. 이는 다음을 의미합니다:
생산의 오른쪽에 “[empty]”라는 문구가 나타나면, 해당 생산의 오른쪽에 단말 또는 비단말이 없음을 나타냅니다.
5.1.5.7 전방 탐색 제한
생산의 오른쪽에 “[lookahead = seq]” 문구가 나타나면, 해당 생산은 토큰 시퀀스 seq가 즉시 뒤따르는 입력 토큰
시퀀스의 접두사인 경우에만 사용할 수 있음을 나타냅니다. 마찬가지로 “[lookahead ∈ set]”에서 set은
유한하고 비어 있지 않은 토큰
시퀀스 집합일 때, 해당 생산은 집합의 일부 요소가 즉시 뒤따르는 토큰 시퀀스의 접두사인 경우에만 사용할 수 있음을 나타냅니다. 편의를 위해 집합을 비단말로도 쓸 수
있는데, 이 경우 해당 비단말이 확장될 수 있는 모든 토큰 시퀀스의 집합을 나타냅니다. 만약 비단말이 무한히 많은 토큰 시퀀스로 확장될 수 있다면 이는 편집상 오류로
간주됩니다.
이 조건들은 부정될 수 있습니다. “[lookahead ≠ seq]”는 seq가 즉시 뒤따르는 입력 토큰 시퀀스의 접두사가
아닌 경우에만 해당 생산을 사용할 수 있음을 나타내며, “[lookahead ∉ set]”는 어느 요소도 즉시
뒤따르는 토큰 시퀀스의 접두사가 아닌 경우에만 해당 생산을 사용할 수 있음을 나타냅니다.
이 정의는 n 문자 뒤에 하나 이상의 십진수 숫자가 오는데, 첫 번째 숫자가 짝수인 경우, 또는 십진수 숫자가 뒤에 다른 십진수 숫자가 오지
않는 경우를 매칭합니다.
이러한 문구가 구문 문법에서 사용될 때는, 즉시 뒤따르는 토큰 시퀀스를 명확하게 식별하는 것이 불가능할 수 있습니다. 이후 토큰을 결정하려면 이후 위치에서 사용할
렉시컬 목표 기호를 알아야 하기 때문입니다. 따라서 구문 문법에서
이러한 제한이 사용될 때, 토큰 시퀀스 seq가 전방 탐색 제한에(집합의 일부로 포함되는 경우 포함하여) 나타나고, 사용되는 렉시컬
목표 기호의 선택에 따라 seq가 결과 토큰
시퀀스의 접두사가 될 수 있는지 여부가 달라진다면, 이는 편집상 오류로 간주됩니다.
명세에서는 종종 번호가 매겨진 목록을 사용하여 알고리즘의 단계를 지정합니다. 이러한 알고리즘은 ECMAScript 언어 구성 요소의 필수 의미를 정확히 명시하는 데 사용됩니다. 이
알고리즘들은 특정 구현 기법의 사용을 암시하려는 의도가 아닙니다. 실제로는 주어진 기능을 구현할 때 더 효율적인 알고리즘이 있을 수 있습니다.
알고리즘은 명시적으로 매개변수화될 수 있으며, 쉼표로 구분된 순서의 별칭 이름 시퀀스를 사용하여, 알고리즘 단계 내에서 해당 위치에 전달된 인수를 참조할 수 있습니다. 선택적
매개변수는 괄호([ , name ])로 둘러싸여 있으며, 알고리즘 단계 내에서는 필수 매개변수와 다르지 않습니다. 나머지 매개변수(rest parameter)는
매개변수 목록의 끝에 ...name 형태로 나타나며, 필수 및 선택적 매개변수 뒤에 제공된 모든 인수를 List에 담습니다. 추가 인수가 없다면 해당
List는 비어 있습니다.
알고리즘 단계는 순차적 하위 단계로 세분화될 수 있습니다. 하위 단계는 들여쓰기되며, 자체적으로 추가 하위 단계로 나눌 수 있습니다. 개요 번호 규칙에 따라 첫 번째 하위 단계는
소문자 알파벳, 두 번째 하위 단계는 소문자 로마 숫자가 사용됩니다. 세 단계보다 많으면 네 번째 단계는 숫자 라벨을 사용하며, 예시는 다음과 같습니다:
최상위 단계
하위 단계.
하위 단계.
하위하위 단계.
하위하위하위 단계
하위하위하위하위 단계
하위하위하위하위하위 단계
단계 또는 하위 단계는 “if” 조건문으로 작성되어 그 하위 단계를 조건부로 적용할 수 있습니다. 이 경우, 조건이 참일 때만 하위 단계가 적용됩니다. 단계 또는 하위 단계가
“else”로 시작하면, 같은 수준의 앞선 “if” 조건문의 부정 조건입니다.
단계는 그 하위 단계를 반복적으로 적용한다고 명시할 수 있습니다.
“Assert:”로 시작하는 단계는 알고리즘의 불변 조건을 주장합니다. 이러한 주장은 암묵적인 알고리즘적 불변
조건을 명시적으로 드러내기 위해 사용됩니다. 이러한 주장은 추가적인 의미적 요구사항을 부과하지 않으므로 구현체에서 반드시 검사할 필요는 없습니다. 오로지 알고리즘을 명확히 하기
위해 사용됩니다.
알고리즘 단계에서는 “Let x be someValue” 형태로 명명된 별칭(alias)을 선언할 수 있습니다. 이 별칭은 참조처럼 동작하여
x와 someValue 모두 동일한 데이터 기반을 참조하며, 둘 중 하나를 변경하면 모두에게 반영됩니다. 참조와 같은 동작을 피하고 싶다면
“Let x be a copy of someValue”처럼 오른쪽 값을 복사하도록 명시해야 하며, 이는
someValue의 얕은 복사본을 생성합니다.
한 번 선언된 별칭은 이후 단계에서 참조할 수 있으며, 별칭 선언 이전의 단계에서는 참조해서는 안 됩니다. 별칭은 “Set x to
someOtherValue” 형태로 수정할 수 있습니다.
5.2.1 추상 연산
명세의 여러 부분에서 사용될 수 있도록, 일부 알고리즘은 추상 연산이라 불리며, 이름이 붙고 매개변수화된 함수 형태로 작성되어
다른 알고리즘에서 이름으로 참조될 수 있습니다. 추상 연산은 보통 OperationName(arg1, arg2)과 같은 함수 호출
방식으로 참조됩니다. 일부 추상 연산은 클래스와 유사한 명세 추상화의 다형적으로 호출되는 메서드로 취급되기도 합니다. 이러한 메서드형 추상 연산은 일반적으로
someValue.OperationName(arg1, arg2)와 같은 메서드 호출 방식으로 참조됩니다.
5.2.2 구문 지향 연산
구문 지향 연산이란, 하나 이상의 ECMAScript 문법
생산에 연결된 알고리즘으로 구성된 이름 있는 연산입니다. 여러 대안 정의가 있는 생산은 일반적으로 각 대안마다 별도의 알고리즘을 가집니다. 알고리즘이 문법 생산에 연결되면,
해당 대안의 단말 및 비단말 기호를 알고리즘의 매개변수처럼 참조할 수 있습니다. 이 방식에서 비단말 기호는 소스 텍스트를 파싱할 때 실제로 일치한 대안 정의를 참조합니다.
문법 생산이나 그로부터 파생된 파싱
노드가 일치시킨 소스 텍스트란, 일치에 참여한 첫 번째 단말부터 마지막 단말까지의 소스 텍스트 부분을 의미합니다.
알고리즘이 생산 대안에 연결되면, 대안은 일반적으로 “[ ]” 문법 주석 없이 표시됩니다. 이러한 주석은 대안의 구문 인식에만 영향을 주며, 연결된 의미에는 영향을 주지
않습니다.
구문 지향 연산은 파싱 노드와 필요하다면 추가 매개변수를 전달하여, 다음 알고리즘의 1, 3, 4 단계 규칙을 따라 호출됩니다:
Let status be SyntaxDirectedOperation of
SomeNonTerminal.
Let someParseNode be the parse of some source text.
Perform SyntaxDirectedOperation of
someParseNode.
Perform SyntaxDirectedOperation of
someParseNode with argument "value".
명시적으로 달리 지정하지 않는 한, 모든 연쇄 생산은 해당 생산의 왼쪽 비단말에 적용될 수 있는 모든 연산에
대한 암묵적 정의를 가집니다. 암묵적 정의는 동일한 연산을 동일한 매개변수로, 해당 연쇄 생산의 유일한 오른쪽 비단말에 다시
적용한 뒤 그 결과를 반환합니다. 예를 들어, 어떤 알고리즘이 “Return Evaluation of Block” 단계를 가진다고 가정하고, 다음과 같은 생산이 있다고 합시다:
문맥 자유 문법만으로는 입력 요소 스트림이 평가 가능한 유효한 ECMAScript Script 또는 Module인지 결정하는 모든 규칙을 표현하기에는 충분하지 않습니다. 어떤 상황에서는
ECMAScript 알고리즘 규칙이나 산문적 요구사항으로 표현되는 추가 규칙이 필요합니다. 이러한 규칙은 항상 문법 생산에 연결되며, 해당 생산의 정적 의미라 불립니다.
정적 의미 규칙은 이름을 가지며, 보통 알고리즘으로 정의됩니다. 이름 있는 정적 의미 규칙은 문법 생산에 연결되고, 여러 대안 정의가 있는 생산은 각 대안마다 적용 가능한
이름 있는 정적 의미 규칙에 대해 별도의 알고리즘을 가집니다.
정적 의미 규칙의 특수한 종류가 조기 오류 규칙입니다. 조기 오류 규칙은 특정 문법 생산과
연결된 조기 오류 조건을
정의합니다(17 절 참조). 대부분의
조기 오류 규칙에 대한
Evaluation
호출은 명세 알고리즘 내에서 명시적으로 호출되지 않습니다. 적합한 구현체는 Script 또는 Module을 최초로 평가하기 전에, 해당 Script 또는 Module을 파싱하는 데 사용된 모든 생산의 조기 오류 규칙을 검사해야 합니다. 만약 조기 오류 규칙이 위반되면, 해당
Script 또는 Module은 유효하지 않으며 평가될 수 없습니다.
이 명세에서 수치 값은 아래첨자 접미사를 통해 서로 다른 숫자 종류로 구분됩니다. 𝔽는 Number, ℤ는 BigInt를 의미합니다.
접미사가 없는 수치 값은 수학적 값을 의미합니다. 대부분의 수치 값은 10진수로 표기되며, 0x로 시작하는
경우 16진수 값입니다.
일반적으로 명세에서 "the length of y" 또는 "the integer represented by the four hexadecimal digits ..."처럼
숫자 종류를 명시하지 않을 때는 수학적 값을 의미합니다. Number 또는 BigInt 값은 명시적으로 표시됩니다.
예: "the Number
value for the number of code points in …" 또는 "the BigInt value
for …".
명세에서 정수(integer)란 별도 명시가 없는 한 수학적 값
중 정수 집합에 속하는 값을
의미합니다. 정수(Number)란 유한 Number 값 중 수학적
값이 정수 집합에 속하는 값을 의미합니다.
+, ×, =, ≥ 등의 수치 연산자는 피연산자의 타입에 따라 해당 연산을 의미합니다. 수학적 값에 적용하면 일반적인 수학 연산을 의미합니다.
확장 수학적 값에 적용하면 확장 실수에 대한 연산을 의미하며,
결정할 수 없는 형태는 정의되지 않으며 명세에서 사용하면 편집상 오류입니다. Number에 적용하면 IEEE 754-2019의 관련 연산을 의미합니다.
BigInt에 적용하면 해당 BigInt의 수학적 값에 대한 일반적인 수학 연산을 의미합니다. 서로 다른 타입의
피연산자(예: Number와 수학적 값)에 적용된 수치 연산자는 정의되지 않으며, 명세에서 사용하면 편집상
오류입니다.
수학적
값과 Number 또는 BigInt 간 변환은 항상 명시적으로 이루어집니다. 수학적 값
또는 확장 수학적 값x를 Number로 변환하는
것은 "the Number
value forx" 또는 𝔽(x)으로 표기하며, 6.1.6.1에서 정의됩니다.
정수x를
BigInt로 변환하는 것은 "the BigInt value for
x" 또는 ℤ(x)으로 표기합니다.
Number 또는 BigInt x를 수학적 값으로 변환하는 것은 "the mathematical value of x" 또는
ℝ(x)으로 표기합니다. mathematical
value of+0𝔽 와
-0𝔽은 수학적 값 0입니다. mathematical
value of 비-유한 값은 정의되지 않습니다. extended mathematical value of x는 유한 값에서는 mathematical
value ofx와 동일하며, +∞𝔽 및
-∞𝔽에는 +∞, -∞이고, NaN에는 정의되지 않습니다.
수학 함수 abs(x)는 x의
절대값을 반환하며, x < 0이면 -x, 그렇지 않으면
x 자체입니다.
수학 함수 min(x1, x2, … ,
xN)는 x1부터 xN 중 가장 작은 값을 반환합니다. max(x1, x2, ..., xN)는 가장 큰 값을
반환합니다. 이 함수들의 정의역과 치역은 확장 수학적 값입니다.
표기 “x modulo
y”(y는 유한이며 0이 아니어야 함)은 y와 부호가 같거나 0인 k 값을
계산하며, abs(k) < abs(y)이고,
x - k = q × y인 정수q가 존재합니다.
“the result of clamping x between
lower and upper”(x는 확장
수학적 값, lower, upper는 수학적
값이고 lower ≤ upper)은 x <
lower면 lower를, x > upper면 upper를, 그렇지
않으면 x를 반환합니다.
수학 함수 floor(x)는
x보다 크지 않은 가장 큰 정수(+∞에 가장 가까운)를 반환합니다.
예를 들어, 1(포함)에서 2(배타)까지의 구간은 1과 2 사이의 모든 수학적 값을 포함하며, 1은 포함하고 2는 포함하지
않습니다. 구간 정의를 위해 -0𝔽 < +0𝔽이므로,
예를 들어 하한이 +0𝔽인 포함 구간은
+0𝔽는 포함하지만 -0𝔽는 포함하지 않습니다.
NaN은 어떤 구간에도 포함되지 않습니다.
5.2.6 값 표기법
이 명세에서 ECMAScript 언어 값은 굵은
글씨로 표시됩니다. 예시로 null, true,
"hello" 등이 있습니다. 이는 ECMAScript 소스 텍스트(예:
Function.prototype.apply 또는 let n = 42;)와 구별됩니다.
5.2.7 동일성(Identity)
이 명세에서는 명세 값과 ECMAScript 언어 값 모두 동등성 비교를 수행합니다.
비교 시 값은 두 범주로 나뉩니다. 동일성 없는 값(value without identity)은 모든 고유 특성이 같으면 서로 동등합니다— 예: 정수의 크기, 시퀀스의 길이 등. 동일성 없는
값은 특성을 완전히 기술하는 것만으로도 나타낼 수 있습니다. 반면, 동일성 있는
값(value with identity)은 고유하며 자기 자신과만 동등합니다. 동일성 있는 값은 동일성 없는 값과 같지만 identity라
불리는 추가적이고 유일하며 변하지 않는 특성을 가집니다. 기존 동일성 있는 값에 대한 참조는 단순히 특성을 기술하는 것만으로 생성할 수 없으며, 반드시 명시적으로 전달되어야
합니다. 동일성 있는 값 중 일부는 변경 가능(mutable)하며, 특성(동일성 제외)이 변경될 수 있어 모든 참조자에게 새로운 특성이 관찰됩니다. 동일성 없는 값은 동일성
있는 값과 절대 동등하지 않습니다.
명세 관점에서 “is”는 두 값을 동등성 비교하는 데 사용되며(예: “If bool is true, then ...”),
“contains”는 리스트 내에서 동등성 비교로 값을 찾는 데 사용됩니다(예: "If list contains a Recordr such
that r.[[Foo]] is true, then ...").
명세 동일성은 이러한 비교의 결과를 결정하며, 이 명세에서 공리적으로 정의됩니다.
이 명세의 알고리즘은 각 값이 관련 타입을 가진 값을 다룹니다. 가능한 값 타입은 바로 이 절에서 정의된 타입들입니다. 타입은 ECMAScript 언어 타입과 명세 타입으로 더 분류됩니다.
6.1 ECMAScript 언어 타입
ECMAScript 언어 타입은 ECMAScript 프로그래머가
ECMAScript 언어를 사용하여 직접 다루는 값에 해당합니다.
ECMAScript 언어 타입에는 Undefined, Null, Boolean, String, Symbol, Number, BigInt, Object가 있습니다.
ECMAScript 언어 값은 ECMAScript 언어 타입으로
특징지어지는 값입니다.
6.1.1 Undefined 타입
Undefined 타입은 undefined라 불리는 정확히 하나의 값을 가집니다. 값이 할당되지 않은 변수는
undefined 값을 가집니다.
6.1.2 Null 타입
Null 타입은 null이라 불리는 정확히 하나의 값을 가집니다.
6.1.3 Boolean 타입
Boolean 타입은
true와 false라 불리는 두 값을 가지는 논리적 개체를 나타냅니다.
6.1.4 String 타입
String 타입은 253 - 1개의
요소까지 0개 이상의 16비트 부호 없는 정수 값(“요소”)의 모든 순서 있는 시퀀스의 집합입니다. String 타입은 일반적으로 실행 중인
ECMAScript 프로그램에서 텍스트 데이터를 표현하는 데 사용되며, 이 경우 String의 각 요소는 UTF-16 코드 유닛 값으로 처리됩니다. 각 요소는 시퀀스 내에서
위치를 차지합니다. 이 위치는 0 이상의 정수로 인덱싱됩니다. 첫 번째 요소(있다면)는 인덱스 0에, 그 다음 요소는 인덱스 1에, 이런 식으로
이어집니다. String의 길이는 그 안의 요소(즉, 16비트 값) 개수입니다. 빈 문자열은 길이가 0이며 요소를 포함하지 않습니다.
String 내용을 해석하지 않는 ECMAScript 연산은 추가 의미를 적용하지 않습니다. String 값을 해석하는 연산은 각 요소를 하나의 UTF-16 코드 유닛으로
처리합니다. 하지만 ECMAScript는 이러한 코드 유닛의 값이나 관계를 제한하지 않으므로, String 내용을 UTF-16로 인코딩된 유니코드 코드 포인트 시퀀스로 추가
해석하는 연산은 잘못된 서브시퀀스를 고려해야 합니다. 그러한 연산은 다음 규칙에 따라 0xD800부터 0xDBFF까지의 포함
구간에 있는 코드 유닛(유니코드 표준에서 선행 서러게이트, 더 공식적으로는 고서러게이트 코드
유닛)과 0xDC00부터 0xDFFF까지의 포함 구간에 있는 코드 유닛(후행 서러게이트, 더 공식적으로는 저서러게이트 코드
유닛)을 특별히 처리합니다:
String.prototype.normalize 함수(22.1.3.15)는 String 값을
명시적으로 정규화하는 데 사용할 수 있습니다. String.prototype.localeCompare(22.1.3.12)는 내부적으로 String 값을
정규화하지만, 그 외 연산은 문자열을 암묵적으로 정규화하지 않습니다. 연산 결과는 달리 명시되지 않는 한, 언어 또는 로케일에 민감하지 않습니다.
참고
이 설계의 근거는 문자열 구현을 최대한 단순하고 빠르게 유지하기 위함이었습니다. ECMAScript 소스 텍스트가 정규형
C(Normalized Form C)라면, 문자열 리터럴도 유니코드 이스케이프 시퀀스를 포함하지 않는 한 정규화됨이 보장됩니다.
이 명세에서 “A, B, ...의 문자열
연결(string-concatenation)”(각 인자는 String 값, 코드 유닛, 코드 유닛 시퀀스임)은 각 인자의 코드 유닛(순서대로)을
이어붙인(순서대로) 코드 유닛 시퀀스로 구성된 String 값을 의미합니다.
“S의 inclusiveStart에서 exclusiveEnd까지의 부분 문자열(substring)”(S는 String 값 또는 코드 유닛 시퀀스,
inclusiveStart와 exclusiveEnd는 정수)는 S의 인덱스 inclusiveStart에서 시작해
exclusiveEnd 바로 앞까지의 연속된 코드 유닛으로 구성된 String 값을 의미합니다(만약 inclusiveStart =
exclusiveEnd이면 빈 문자열). “to” 접미사가 생략되면 S의 길이가 exclusiveEnd 값으로
사용됩니다.
“ASCII 단어 문자”는 다음 String 값을 의미합니다. 이 값은 유니코드
기본 라틴 블록 내의 모든 문자와 숫자 및 U+005F(LOW LINE)만으로 구성됩니다: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_".
역사적 이유로 여러 알고리즘에서 의미가 있습니다.
이전 판 명세에서는 @@name 형태의 표기를 사용했으나, 현재 판에서는
%Symbol.name%를 사용합니다. 특히 다음 이름이 사용되었습니다: @@asyncIterator, @@hasInstance,
@@isConcatSpreadable, @@iterator, @@match, @@matchAll,
@@replace, @@search, @@species, @@split, @@toPrimitive, @@toStringTag, 그리고
@@unscopables.
자신의 프로퍼티 이름 및 상속된 프로퍼티 이름이 관련 객체의 with 환경 바인딩에서 제외되는 프로퍼티
이름인 객체 값 프로퍼티입니다.
6.1.6 숫자 타입
ECMAScript에는 두 가지 내장 숫자 타입이 있습니다: Number와 BigInt. 아래 추상 연산들은 이러한 숫자 타입에
대해 정의되어 있습니다. "결과" 열에는 반환 타입과, 일부 연산 호출 시 비정상 완료(abrupt
completion)가 반환될 수 있는지 여부가 표시됩니다.
숫자 타입은 일반적으로 정밀도 손실이나 잘림(truncation) 없이 변환할 수 없기 때문에, ECMAScript 언어에서는 이러한 타입 간에 암묵적인 변환을 제공하지
않습니다. 프로그래머는 다른 타입을 요구하는 함수를 호출할 때 Number 또는 BigInt 함수를 명시적으로 호출하여 타입을
변환해야 합니다.
참고
ECMAScript의 초판 및 이후 판에서는 일부 연산자에 대해 정밀도 손실이나 잘림(truncate)이 발생할 수 있는 암묵적 숫자 변환을 제공했습니다.
이러한 레거시 암묵 변환은 하위 호환성을 위해 유지되지만, BigInt에는 제공되지 않습니다. 이는 프로그래머의 실수 가능성을 줄이고, 미래 판에서는 일반화된
값 타입(value types) 도입의 여지를 남기기 위함입니다.
6.1.6.1 Number 타입
Number 타입은 정확히
18,437,736,874,454,810,627개(즉, 264 - 253 +
3) 값을 가지며, IEEE 754-2019에서 지정된 IEEE 배정밀도
부동소수점(binary64) 값을 나타냅니다. 단, IEEE 표준의 9,007,199,254,740,990개(즉, 253 - 2) NaN 값은 ECMAScript에서는 하나의 특별한
NaN 값으로 표현됩니다. (NaN 값은 프로그램 표현식 NaN으로
생성됩니다.) 일부 구현에서는 외부 코드가 다양한 NaN 값을 구분할 수 있지만, 그러한 동작은 구현
정의(implementation-defined)입니다. ECMAScript 코드에서는 모든
NaN 값은 서로 구별되지 않습니다.
참고
Number 값이 ArrayBuffer(25.1)나
SharedArrayBuffer(25.2)에 저장된 후 관찰되는 비트
패턴은 ECMAScript 구현에서 사용하는 Number 값의 내부 표현과 반드시 같지 않을 수 있습니다.
그 외에도 양의 무한대(positive Infinity)와 음의 무한대(negative
Infinity)라는 두 개의 특별한 값이 있습니다. 간결하게 각각 +∞𝔽와
-∞𝔽로도 설명합니다. (이 두 무한대 Number 값은 +Infinity(또는
Infinity)와 -Infinity 표현식으로 생성됩니다.)
나머지 18,437,736,874,454,810,624개(즉, 264 -
253) 값은 유한(finite) 숫자라 불립니다. 이
중 절반은 양수, 절반은 음수입니다. 모든 유한 양의 Number 값에는 동일한 크기의 음수 값이 대응됩니다.
양의 0(positive zero)와 음의 0(negative zero)도 있습니다. 간결하게 각각
+0𝔽와 -0𝔽로 설명합니다. (이 두 0 값은
+0(또는 0)과 -0 표현식으로 생성됩니다.)
18,437,736,874,454,810,622개(즉, 264 - 253 -
2) 유한
0이 아닌 값은 두 가지 종류가 있습니다:
18,428,729,675,200,069,632개(즉, 264 -
254)는 정규화(normalized)되어 있으며, 다음과 같은 형태를 가집니다:
s × m × 2e
여기서 s는 1 또는 -1, m은 정수이며 구간(interval) [252, 253)에 속하고,
e는 정수이며 포함 구간 [-1074, 971]에 속합니다.
나머지 9,007,199,254,740,990개(즉, 253 - 2) 값은
비정규화(denormalized)되어 있으며, 다음과 같은 형태를 가집니다:
s × m × 2e
여기서 s는 1 또는 -1, m은 정수이며 구간(interval) (0, 252)에 속하고, e는
-1074입니다.
크기가 253 이하인 모든 양의 및 음의 정수는 Number 타입으로 표현 가능합니다. 정수 0은 Number 타입에서
+0𝔽와 -0𝔽 두 가지로 표현됩니다.
유한 숫자가 0이 아니고 위의 두
형태 중 정수m이 홀수이면 홀수 시그니피컨드(odd significand)를 가지며, 그렇지 않으면 짝수 시그니피컨드(even
significand)를 가집니다.
이 명세에서 “the Number value for x”라는 문구에서 x가
정확한 실수(π와 같은 무리수 포함)를 나타낼 때, 다음 방식으로 Number 값을 선택함을 의미합니다. Number 타입의 모든 유한 값 집합에서
-0𝔽을 제거하고, Number 타입으로 표현할 수 없는 두 값을 추가합니다:
21024(+1 × 253 × 2971)와
-21024(-1 ×
253 × 2971). 이 집합에서 x에 가장 가까운 값을 선택합니다. 두 값이
동일하게 가까울 경우, 짝수 시그니피컨드를 가진 값을 선택합니다. 이때 두 추가 값 21024와 -21024은 짝수 시그니피컨드를 가진 것으로 간주합니다. 마지막으로,
21024가 선택되면 +∞𝔽로, -21024가 선택되면 -∞𝔽로,
+0𝔽가 선택되면 x < 0일 때만
-0𝔽로 바꿉니다. 그 외의 경우 선택한 값을 그대로 사용합니다. 그 결과가 Number value
forx입니다. (이 절차는 IEEE 754-2019의 roundTiesToEven
모드와 정확히 일치합니다.)
일부 ECMAScript 연산자는 정수의 특정 범위(예: 포함 구간-231부터 231 -
1까지, 또는 포함 구간 0부터 216 - 1까지)만 다룹니다. 이러한 연산자는 Number 타입의 모든 값을 허용하지만,
우선 해당 값을 기대하는 범위의 정수 값으로 변환합니다. 숫자 변환 연산에 대한 설명은 7.1를 참조하세요.
6.1.6.1.1 Number::unaryMinus ( x )
추상 연산 Number::unaryMinus는 인자 x(Number)를 받고 Number를 반환합니다. 호출 시 다음 단계를 수행합니다:
x가 NaN이면 NaN을 반환한다.
x의 부호를 반전한 값을 반환한다. 즉, 크기는 같지만 부호가 반대인 Number를 계산한다.
6.1.6.1.2 Number::bitwiseNOT ( x )
추상 연산 Number::bitwiseNOT는 인자 x(Number)를 받고 정수(Number)를 반환합니다. 호출 시 다음
단계를 수행합니다:
구현 근사값 Number 값을
반환하며, 이는 ℝ(base)를 ℝ(exponent) 거듭제곱한 값이다.
참고
base가 1𝔽 또는
-1𝔽이고 exponent가
+∞𝔽 또는 -∞𝔽인 경우, 또는
base가 1𝔽이고 exponent가
NaN인 경우의 base**exponent
결과는 IEEE 754-2019와 다릅니다. ECMAScript
초판은 이 연산에서 NaN을 반환했지만, 이후 IEEE 754에서는
1𝔽을 명시합니다. 호환성 유지를 위해 ECMAScript의 역사적 동작을 따릅니다.
6.1.6.1.4 Number::multiply ( x, y )
추상 연산 Number::multiply는 인자 x(Number), y(Number)를 받고 Number를 반환합니다.
IEEE
754-2019 배정밀도 이진 산술 규칙에 따라 곱셈을 수행하여 x와 y의
곱을 생성합니다. 호출 시 다음 단계를 수행합니다:
유한(finite) 정밀 곱셈은 교환법칙은 성립하지만, 항상 결합법칙이
성립하는 것은 아닙니다.
6.1.6.1.5 Number::divide ( x, y )
추상 연산 Number::divide는 인자 x(Number), y(Number)를 받고 Number를 반환합니다.
IEEE
754-2019 배정밀도 이진 산술 규칙에 따라 나눗셈을 수행하며, x를
피제수(dividend), y를 제수(divisor)로 하여 몫을 생성합니다. 호출 시 다음 단계를 수행합니다:
C와 C++에서 나머지 연산자는 정수 피연산자만 허용하지만, ECMAScript에서는 부동소수점 피연산자도 허용합니다.
참고 2
% 연산자로 계산된 부동소수점 나머지 연산 결과는 IEEE 754-2019에서
정의한 "나머지(remainder)" 연산과 동일하지 않습니다. IEEE의 "remainder" 연산은 잘림이 아닌 반올림 나눗셈에서의 나머지를
계산하므로, 일반적인 정수 나머지 연산자와는 다릅니다. ECMAScript에서는 부동소수점
% 연산이 Java 정수 나머지 연산자와 유사하게 동작하도록 정의되어
있으며, 이는 C 표준 라이브러리의 fmod 함수와 비교할 수 있습니다.
6.1.6.1.7 Number::add ( x, y )
추상 연산 Number::add는 인자 x(Number), y(Number)를 받고 Number를 반환합니다.
IEEE
754-2019 배정밀도 이진 산술 규칙에 따라 덧셈을 수행하여 인자의 합을 생성합니다. 호출 시 다음 단계를
수행합니다:
추상 연산 Number::toString은 인자 x(Number), radix(정수, 포함
구간 2~36)을 받고 String을 반환합니다. x를 radix 진법 위치
표기법(positional numeral system)으로 String으로 표현합니다. r 진법으로 수를 표현할 때 사용하는 숫자는
"0123456789abcdefghijklmnopqrstuvwxyz"의 앞 r 코드 유닛을 순서대로
사용합니다. 크기가 1𝔽 이상인 숫자의 표현에는 선행 0이 포함되지 않습니다. 호출 시 다음 단계를
수행합니다:
n, k,
s를 정수로 정한다. k ≥ 1이며,
radixk - 1 ≤ s <
radixk이고, 𝔽(s ×
radixn - k)가 x이며,
k는 최소가 되도록 한다. k는 s를 radix로 표현할 때의
자릿수이며, s는 radix로 나누어떨어지지 않으며, 최하위 자릿수는 반드시 유일하게 결정되지는 않는다.
단일 자리 s 코드 유닛, 0x0065(LATIN SMALL LETTER E),
exponentSign, abs(n - 1)를 10진수로 표현한
코드 유닛을 string-concatenation하여
반환한다.
상위 자리 s의 10진수 코드 유닛, 0x002E(FULL STOP), 나머지 k - 1자리 10진수
코드 유닛, 0x0065(LATIN SMALL LETTER E), exponentSign, abs(n
- 1)를 10진수로 표현한 코드 유닛을 string-concatenation하여 반환한다.
규칙보다 더 정확한 변환을 제공하는 구현에서는 아래 대체 버전의 5 단계를
가이드라인으로 사용하는 것이 권장됩니다:
n, k, s를 정수로 정한다.
k ≥ 1, radixk - 1 ≤
s < radixk, 𝔽(s ×
radixn - k)가 x이며,
k는 최소가 되도록 한다. s의 후보가 여러 개일 경우, s ×
radixn - k가 ℝ(x)에
가장 가까운 값을 s로 선택한다. 두 후보가 있을 경우 짝수 값을 선택한다. k는
s를 radix로 표현할 때의 자릿수이며, s는
radix로 나누어떨어지지 않는다.
참고 3
ECMAScript 구현자는 David M. Gay가 작성한 부동소수점 이진-10진 변환 관련 논문 및 코드를 참고할 수 있습니다:
BigInt 타입은 정수 값을 나타냅니다.
값의 크기는 제한이 없으며, 특정 비트 폭에 국한되지 않습니다. 별도 언급이 없는 한, 연산은 일반적으로 정확한 수학적 결과를 제공합니다.
이진 연산에서는 BigInt가 2의 보수 이진 문자열로 동작하며, 음수는 왼쪽으로 무한히 비트가 설정된 것으로 취급됩니다.
6.1.6.2.1 BigInt::unaryMinus ( x )
추상 연산 BigInt::unaryMinus는 인자 x(BigInt)를 받고 BigInt를 반환합니다. 호출 시 다음 단계를 수행합니다:
x = 0ℤ이면
0ℤ를 반환한다.
-x를 반환한다.
6.1.6.2.2 BigInt::bitwiseNOT ( x )
추상 연산 BigInt::bitwiseNOT는 인자 x(BigInt)를 받고 BigInt를 반환합니다. x의 1의 보수
값을 반환합니다. 호출 시 다음 단계를 수행합니다:
-x - 1ℤ를 반환한다.
6.1.6.2.3 BigInt::exponentiate ( base,
exponent )
추상 연산 BigInt::exponentiate는 인자 base(BigInt), exponent(BigInt)를 받고
정상 완료 BigInt 또는
예외 완료를 반환합니다.
호출 시 다음 단계를 수행합니다:
exponent < 0ℤ이면
RangeError 예외를 던진다.
base = 0ℤ이고 exponent =
0ℤ이면 1ℤ를 반환한다.
base를 exponent 거듭제곱한 값을 반환한다.
6.1.6.2.4 BigInt::multiply ( x, y )
추상 연산 BigInt::multiply는 인자 x(BigInt), y(BigInt)를 받고 BigInt를 반환합니다.
호출 시 다음 단계를 수행합니다:
x × y를 반환한다.
참고
결과가 입력보다 훨씬 더 큰 비트폭을 갖더라도 정확한 수학적 결과가 반환됩니다.
6.1.6.2.5 BigInt::divide ( x, y )
추상 연산 BigInt::divide는 인자 x(BigInt), y(BigInt)를 받고
정상 완료 BigInt 또는
예외 완료를 반환합니다.
호출 시 다음 단계를 수행합니다:
추상 연산 BigInt::toString은 인자 x(BigInt), radix(정수, 포함
구간 2~36)을 받고 String을 반환합니다. x를 radix 진법 위치
표기법으로 String으로 표현합니다. r 진법으로 BigInt를 표현할 때 사용하는 숫자는
"0123456789abcdefghijklmnopqrstuvwxyz"의 앞 r 코드 유닛을 순서대로
사용합니다. 0ℤ이 아닌 BigInt의 표현에는 결코 선행 0이 포함되지 않습니다. 호출 시 다음 단계를
수행합니다:
접근자 프로퍼티는 키 값을 하나 또는 두 개의 접근자 함수와
Boolean 속성 집합에 연결합니다. 접근자 함수는 해당 프로퍼티에 연결된 ECMAScript 언어 값를
저장하거나 검색하는 데 사용됩니다.
오브젝트의 프로퍼티는 프로퍼티
키를 사용하여 고유하게 식별됩니다. 프로퍼티 키는
문자열(String) 또는 심볼(Symbol)입니다. 빈 문자열을 포함한 모든 문자열과 심볼은 프로퍼티 키로 사용할 수 있습니다. 프로퍼티 이름은 프로퍼티 키 중 문자열(String)인 값입니다.
프로퍼티 키는 프로퍼티
및 그 값을 접근하는 데 사용됩니다. 프로퍼티 접근 방법에는 get(값 조회)과 set(값 할당)의 두 가지가 있습니다. get/set
접근으로 접근 가능한 프로퍼티에는 오브젝트의 자신의 프로퍼티(own properties)와, 프로퍼티 상속 관계를 통해 다른 연관 객체가 제공하는
상속 프로퍼티(inherited properties)가 포함됩니다. 상속 프로퍼티는 연관 객체의 own이나 inherited 프로퍼티일 수 있습니다. 한
오브젝트의 모든 own 프로퍼티는 서로 다른 키 값을 가져야 합니다.
모든 오브젝트는 논리적으로 프로퍼티의 집합이지만, 프로퍼티 접근 및 조작의 의미론에 따라 여러 형태의 오브젝트가 존재합니다. 다양한 오브젝트 형태에 대한 정의는
6.1.7.2를 참고하세요.
또한 일부 오브젝트는 호출할 수 있습니다. 이들은 함수 또는 함수 오브젝트라 부르며, 아래에서 더 자세히 설명합니다. ECMAScript의 모든
함수는 Object 타입의 멤버입니다.
6.1.7.1 프로퍼티 속성
속성은 이 명세에서 표 3에 설명된 대로 객체 프로퍼티의 상태를
정의하고 설명하는 데 사용됩니다. 명시적으로 지정하지 않는 한, 각 속성의 초기값은 기본값(Default Value)입니다.
값이 오브젝트라면, 반드시 함수
오브젝트여야 합니다. 함수의 [[Call]]
내부 메서드(표
5)가 단일 인자로 할당값을 넘겨 호출되며, set 접근 시마다 실행됩니다. 프로퍼티의
[[Set]] 내부 메서드의 효과는, 이후 [[Get]] 내부 메서드 호출 결과에 영향을 줄 수도 있고, 주지 않을 수도
있습니다.
false인 경우, 해당 프로퍼티를 삭제하거나, 데이터 프로퍼티를 접근자 프로퍼티로, 또는 반대로 변경하거나,
(기존 [[Value]] 교체나 [[Writable]]을 false로 변경하는 경우를
제외하고) 속성에 변경을 가하려 해도 실패합니다.
6.1.7.2 오브젝트 내부 메서드와 내부 슬롯
ECMAScript에서 오브젝트의 실제 의미론은 내부 메서드라 불리는 알고리즘으로 지정됩니다. ECMAScript 엔진의 각 오브젝트는 런타임 동작을
정의하는 일련의 내부 메서드와 연관되어 있습니다. 이러한 내부 메서드는 ECMAScript 언어의 일부가 아니며, 명세상 설명 목적으로만 정의됩니다. 하지만
ECMAScript 구현 내의 각 오브젝트는 해당 내부 메서드가 명세한 대로 동작해야 합니다. 그 구현 방식은 구현체에 따라 다릅니다.
내부 메서드 이름은 다형적입니다. 즉, 동일한 내부 메서드 이름이 호출될 때 오브젝트 값에 따라 서로 다른 알고리즘이 실행될 수 있습니다. 내부 메서드가 호출되는 실제
오브젝트가 "타겟"입니다. 런타임 시 어떤 알고리즘이 오브젝트가 지원하지 않는 내부 메서드를 사용하려고 하면 TypeError
예외가 발생합니다.
내부 슬롯은 오브젝트와 연관된 내부 상태를 나타내며, 다양한 ECMAScript 명세 알고리즘에서 사용됩니다. 내부 슬롯은 오브젝트 프로퍼티가 아니며 상속되지도
않습니다. 내부 슬롯 명세에 따라 해당 상태는 ECMAScript 언어 타입 또는 명세 타입 값일 수
있습니다. 별도 명시가 없는 한, 내부 슬롯은 오브젝트 생성 과정에서 할당되며, 동적으로 추가될 수 없습니다. 별도 명시가 없는 한, 내부 슬롯의 초기값은
undefined입니다. 명세의 다양한 알고리즘은 내부 슬롯이 있는 오브젝트를 생성합니다. 하지만 ECMAScript 언어
자체에서는 오브젝트에 내부 슬롯을 직접 연결할 방법이 없습니다.
모든 오브젝트는 [[PrivateElements]]라는 내부 슬롯을 갖는데, 이는 List 타입의 PrivateElements 목록입니다.
이 List는 해당 오브젝트의 private
필드, 메서드, 접근자의 값을 나타냅니다. 초기값은 빈 List입니다.
내부 메서드와 내부 슬롯은 명세에서 [[ ]]로 감싸서 표기됩니다.
표 4는 ECMAScript 코드로 생성하거나
조작할 수 있는 모든 오브젝트에 적용되는 필수 내부 메서드를 요약합니다. 모든 오브젝트는 이 필수 내부 메서드의 알고리즘을 가져야 합니다. 그러나
모든 오브젝트가 반드시 동일한 알고리즘을 사용하는 것은 아닙니다.
이 명세는 오브젝트의 내부 메서드에 따라 다양한 이색 오브젝트 유형을 구분합니다. 어떤 오브젝트가 특정 종류의 이색 오브젝트(예:
배열 이색
오브젝트 또는 바운드 함수 이색 오브젝트 등)와
동작상 동일하더라도 명세된 내부 메서드 모음을 모두 갖추지 않으면 그 종류로 인식되지 않습니다.
표 4의 “시그니처(Signature)” 열 및
유사한 표들은 각 내부 메서드의 호출 패턴을 설명합니다. 호출 패턴에는 항상 괄호로 감싼 설명적 인자 이름들이 포함됩니다. 인자 이름이 ECMAScript 타입명과
같으면 해당 타입이어야 함을 의미합니다. 내부 메서드가 명시적으로 반환값을 가지면 인자 목록 뒤에 “→”와 반환 타입이 붙습니다. 이 시그니처에 쓰인 타입 이름은
6절 정의에 다음 명칭이 추가된 것입니다.
“any”는 ECMAScript 언어 타입 중 아무 값이나 올 수
있음을 의미합니다.
이 오브젝트의 own 프로퍼티 중 propertyKey를 키로 하는 프로퍼티에 대한 Property
Descriptor를 반환하거나, 해당 프로퍼티가 없으면
undefined를 반환합니다.
[[DefineOwnProperty]]
(propertyKey, PropertyDescriptor) → Boolean
propertyKey를 키로 하는 own 프로퍼티를 PropertyDescriptor로
기술된 상태로 생성하거나 변경합니다. 성공하면 true, 아니면
false를 반환합니다.
[[HasProperty]]
(propertyKey) → Boolean
이 오브젝트에 propertyKey를 키로 하는 own 또는 상속 프로퍼티가 있는지 Boolean 값으로
반환합니다.
[[Get]]
(propertyKey, Receiver) →any
이 오브젝트에서 propertyKey를 키로 하는 프로퍼티의 값을 반환합니다. 프로퍼티 값을 얻기 위해
ECMAScript 코드를 실행해야 하는 경우, Receiver가 코드 평가 시
this 값으로 사용됩니다.
[[Set]]
(propertyKey, value, Receiver) →
Boolean
propertyKey에 해당하는 프로퍼티의 값을 value로 설정합니다. 프로퍼티 값을
설정하기 위해 ECMAScript 코드를 실행해야 하는 경우, Receiver가 코드 평가 시
this 값으로 사용됩니다. 설정에 성공하면 true,
실패하면 false를 반환합니다.
[[Delete]]
(propertyKey) → Boolean
이 오브젝트에서 propertyKey를 키로 하는 own 프로퍼티를 삭제합니다. 프로퍼티가 삭제되지 않고
여전히 존재하면 false를 반환합니다. 프로퍼티가 삭제됐거나 존재하지 않으면
true를 반환합니다.
표
5는 함수로 호출 가능한 오브젝트가 지원하는 추가 필수 내부 메서드를 요약합니다. 함수 오브젝트는 [[Call]] 내부 메서드를 지원하는 오브젝트이고, 생성자는 [[Construct]]
내부 메서드를 지원하는 오브젝트입니다. [[Construct]]를 지원하는 모든 오브젝트는 반드시 [[Call]]도 지원해야 합니다. 즉, 모든 생성자는 함수
오브젝트여야 합니다. 따라서 생성자는 생성자 함수 또는 생성자함수
오브젝트라고도 부를 수 있습니다.
오브젝트를 생성합니다. new 연산자나 super 호출을 통해 실행됩니다. 내부
메서드의 첫 번째 인자는 List로,
생성자 호출 또는 super 호출의 인자들을 요소로 갖습니다. 두 번째 인자는
new 연산자가 처음 적용된 오브젝트입니다. 이 내부 메서드를 구현한 오브젝트를 생성자라 합니다. 함수
오브젝트가 반드시 생성자인 것은 아니며,
[[Construct]] 내부 메서드가 없는 함수
오브젝트도 있습니다.
일반
오브젝트와 표준 이색 오브젝트의 필수 내부 메서드의 의미론은 10절에 명시되어 있습니다. 만약
이색
오브젝트의 내부 메서드를 구현에서 지원하지 않는 경우, 해당 사용 시 TypeError
예외를 반드시 발생시켜야 합니다.
6.1.7.3 필수 내부 메서드의 불변 조건
ECMAScript 엔진의 오브젝트 내부 메서드는 아래에 명시된 불변 조건(invariant)을 반드시 준수해야 합니다. 이 명세의 일반 ECMAScript 오브젝트
및 모든 표준 이색
오브젝트는 이러한 불변 조건을 유지합니다. ECMAScript Proxy 오브젝트는 [[ProxyHandler]] 오브젝트의 트랩(trap) 결과에 대한 런타임 검사를 통해 이 불변 조건을 유지합니다.
구현체가 제공하는 이색
오브젝트도 반드시 이 불변 조건을 지켜야 합니다. 이러한 불변 조건이 위반되면 ECMAScript 코드에서 예측 불가한
동작이나 보안 문제가 발생할 수 있습니다. 단, 이 불변 조건 위반이 구현체의 메모리 안전성을 절대 해쳐서는 안 됩니다.
구현체는 필수 내부 메서드의 기능을 우회적으로 제공하여 이 불변 조건을 우회할 수 있게 해서는 안 됩니다.
정의(Definitions):
내부 메서드의 target은 해당 내부 메서드가 호출되는 오브젝트입니다.
[[IsExtensible]] 내부 메서드가 false를 반환하거나, [[PreventExtensions]] 내부 메서드가 true를 반환한 경우 그
타겟은 비확장(non-extensible)입니다.
존재하지 않는(non-existent) 프로퍼티란 비확장 타겟에 own 프로퍼티로 존재하지 않는 프로퍼티입니다.
타겟이 비확장이고 [[GetPrototypeOf]]가 값 V를 반환한 경우, 이후 모든
[[GetPrototypeOf]] 호출은 SameValue로 V와 동일한
값을 반환해야 합니다.
참고 2
오브젝트의 프로토타입 체인은 유한 길이를 가져야 합니다(즉, 어떤 오브젝트에서 시작해 [[GetPrototypeOf]] 내부 메서드를 재귀적으로 적용하면 결국
null에 도달해야 함). 하지만 프로토타입 체인에 일반 오브젝트의 정의를 따르지 않는
이색
오브젝트가 포함되면 이 조건은 오브젝트 수준에서 강제할 수 없습니다. 이러한 순환 프로토타입 체인은 오브젝트
프로퍼티 접근 시 무한 루프를 야기할 수 있습니다.
[[SetPrototypeOf]] ( V )
정상 반환 타입은 Boolean입니다.
타겟이 비확장일 때, V가 타겟의 관찰된 [[GetPrototypeOf]] 값과
SameValue가 아닌 한 [[SetPrototypeOf]]는 반드시 false를 반환해야 합니다.
[[IsExtensible]] ( )
정상 반환 타입은 Boolean입니다.
[[IsExtensible]]이 false를 반환한 경우, 이후 해당 타겟의
모든 [[IsExtensible]] 호출은 false를 반환해야 합니다.
[[PreventExtensions]] ( )
정상 반환 타입은 Boolean입니다.
[[PreventExtensions]]이 true를 반환한 경우, 이후 해당
타겟의 모든 [[IsExtensible]] 호출은 false를 반환해야 하며,
타겟은 이제 비확장으로 간주합니다.
P의 [[Writable]] 및 [[Value]]
이외의 속성이 변할 수 있거나, 프로퍼티가 삭제될 수 있다면 P의 [[Configurable]] 속성은 true여야 합니다.
[[Writable]] 속성이 false에서
true로 바뀔 수 있다면, [[Configurable]] 속성도
true여야 합니다.
타겟이 비확장이고 P가 존재하지 않는 own 프로퍼티라면, 이후의 모든 [[GetOwnProperty]] (P) 호출은 P를 존재하지 않는 것으로
설명해야 하며, 즉 [[GetOwnProperty]] (P)는
undefined를 반환해야 합니다.
참고 3
세 번째 불변 조건의 결과로, 어떤 프로퍼티가 데이터 프로퍼티로 기술되고 시간이 지남에 따라 다른 값을 반환할 수
있는 경우, 해당 프로퍼티의 [[Writable]]이나 [[Configurable]] 속성, 또는 둘 다 true여야 합니다.
비록 그 값을 바꿀 수 있는 메커니즘이 다른 필수 내부 메서드로 노출되어 있지 않더라도 말입니다.
[[DefineOwnProperty]] ( P, Desc )
정상 반환 타입은 Boolean입니다.
[[DefineOwnProperty]]는 P가 타겟의 비설정 가능 own 프로퍼티로 관찰된
적이 있다면, 아래 둘 중 하나가 아닌 한 반드시 false를 반환해야 합니다:
잘 알려진 내장 객체들은 이 명세의 알고리즘에 의해 명시적으로 참조되는 내장 객체들이며, 일반적으로 realm별로 고유한 정체성을 가진다. 별도로 명시되지 않는 한, 각 내장
객체는 실제로는 각 realm마다
유사한 객체 집합에 해당한다.
이 명세에서 %name%과 같은 참조는 현재 realm에 연결된, 해당 name에 해당하는 내장 객체를 의미한다. %name.a.b%와 같은
참조는, ECMAScript 코드가 평가되기 전에 내장 객체 %name%의 "a" 속성의 값에서
"b" 속성을 접근한 것과 같다. 현재 realm과 그 내장 객체들의 결정 방법은 9.4에 설명되어 있다. 잘 알려진 내장 객체들의 목록은
표 6에 나와 있다.
Enums는 명세 내부에서만 사용되는 값으로, ECMAScript 코드에서는 직접적으로
관찰할 수 없다. Enum은 sans-serif 글꼴로 표기된다. 예를 들어, Completion Record의 [[Type]] 필드는 normal,
return, 또는 throw와 같은 값을 가진다. Enum은 이름 외의 특징이 없다.
Enum의 이름은 단지 다른 Enum과 구분하기 위한 용도일 뿐이며, 사용법이나 문맥상의 의미를 암시하지 않는다.
6.2.2 List와 Record 명세 타입
List 타입은 new 표현식의 인수 리스트 평가( 13.3.8
참고), 함수 호출, 기타 값의 간단한 순서형 리스트가 필요한 알고리즘의 설명에 사용된다. List 타입의 값은 개별 값으로 구성된 리스트 요소들의 단순한 순서 시퀀스이다.
이 시퀀스의 길이는 임의일 수 있다. 리스트의 요소는 0부터 시작하는 인덱스로 임의 접근이 가능하다. 표기상의 편의를 위해 배열과 유사한 문법으로 List 요소에 접근할 수
있다. 예를 들어, arguments[2]는 List arguments의 세 번째 요소를 의미한다.
알고리즘이 List의 요소를 순서 지정 없이 반복할 때, 사용되는 순서는 List의 요소 순서이다.
이 명세 내에서 표기상의 편의를 위해, 리터럴 문법으로 새 List 값을 표현할 수 있다. 예를 들어, « 1, 2 »는 두 개의 요소를 가지며 각각 특정 값으로 초기화된
List 값을 정의한다. 새로운 빈 List는 « »로 표현할 수 있다.
이 명세에서 "the list-concatenation of A,
B, ..." (각 인수가 비어 있을 수도 있는 List임)은 각 인수의 요소(순서대로)를 연결한 새로운 List 값을 의미한다.
List of String에 대해 "sorted according to lexicographic code unit order"라는 문구는, 짧은 문자열의 길이만큼 각 코드 유닛의 숫자값으로 정렬하고,
모두 같으면 짧은 문자열을 긴 문자열보다 먼저 정렬함을 의미한다. 이는 IsLessThan 추상 연산에서 설명된다.
Record 타입은 이 명세의 알고리즘 내에서 데이터 집합을 설명하는 데 사용된다. Record
타입 값은 하나 이상의 이름 붙은 필드로 구성된다. 각 필드의 값은 ECMAScript 언어 값 또는 명세
값이다. 필드 이름은 항상 이중 대괄호로 감싸며, 예를 들어 [[Value]]와 같다.
이 명세 내에서 표기상의 편의를 위해, 객체 리터럴과 유사한 문법으로 Record 값을 표현할 수 있다. 예를 들어, { [[Field1]]: 42, [[Field2]]:
false, [[Field3]]:
empty }는 세 개의 필드를 각각 특정 값으로 초기화한 Record 값을 정의한다. 필드 이름의 순서는 중요하지 않다.
명시적으로 나열되지 않은 필드는 존재하지 않는 것으로 간주한다.
명세 텍스트와 알고리즘에서는 점 표기법을 사용해 Record 값의 특정 필드를 참조할 수 있다. 예를 들어, 위에서 보인 record R에 대해 R.[[Field2]]는 “R의 [[Field2]]라는 이름의 필드”를 의미한다.
자주 사용되는 Record 필드 조합의 스키마는 이름을 붙일 수 있으며, 그 이름을 리터럴 Record 값에 접두사로 사용하여 특정 집합의 종류를 명확히 할 수 있다. 예:
PropertyDescriptor { [[Value]]: 42, [[Writable]]: false, [[Configurable]]: true }.
6.2.3 Set과 Relation 명세 타입
Set 타입은 메모리 모델에서 사용하기 위한 비순서 요소의 집합을 설명하는 데 사용된다.
ECMAScript의 같은 이름을 가진 컬렉션 타입과는 다르다. 혼동을 피하기 위해, 이 명세에서는 ECMAScript 컬렉션의 인스턴스를 항상 "Set 객체"라고 부른다.
Set 타입의 값은 중복 없는 단순한 요소 집합이며, 요소를 추가하거나 제거할 수 있다. Set끼리는 합집합, 교집합, 차집합 연산이 가능하다.
Relation 타입은 Set에 대한 제약 조건을 설명하는 데 사용된다. Relation
타입의 값은 값 도메인에서의 순서쌍의 Set이다. 예를 들어, 이벤트에 대한 Relation은 이벤트 순서쌍의 집합이다. Relation R과
R의 값 도메인에 속한 두 값 a와 b에 대해, aRb는 순서쌍 (a, b)가 R의 멤버임을 의미하는 약칭이다. Relation이 어떤 조건에
대해 최소 Relation일 때, 이는 그 조건을 만족하는 가장 작은 Relation임을
의미한다.
strict partial order는 Relation 값
R이 다음 조건을 만족할 때를 말한다.
모든 a, b, c가 R의 도메인에 있을 때:
aRa가 아니다.
aRb이고 bRc이면,
aRc이다.
참고 1
위 두 속성은 각각 반사성 없음(irreflexivity)과 추이성(transitivity)이라 한다.
strict total order는 Relation 값
R이 다음 조건을 만족할 때를 말한다.
모든 a, b, c가 R의 도메인에 있을 때:
a가 b와 같거나 aRb이거나
bRa이다.
aRa가 아니다.
aRb이고 bRc이면,
aRc이다.
참고 2
위 세 속성은 각각 전체성(totality), 반사성 없음(irreflexivity), 추이성(transitivity)이라 한다.
6.2.4 완료 레코드 명세 타입
완료 레코드 명세 타입은 값의 런타임 전파와
break, continue, return, throw와 같이 비지역적 제어
흐름 전이를 수행하는 구문의 동작과 같은 제어 흐름을 설명하는 데 사용된다.
empty가 아닌 경우, 해당 Reference
Record는 super키워드를 사용하여 표현된
프로퍼티 바인딩을 나타내며, 이를 Super Reference Record라 한다. 이 경우
[[Base]] 값은 Environment Record가 될
수 없다. 이때 [[ThisValue]] 필드는 this
값(Reference Record가 생성될 당시의 값)을 보유한다.
다음과 같은 Reference
Record를 반환한다: { [[Base]]:
baseValue, [[ReferencedName]]:
privateName, [[Strict]]:
true, [[ThisValue]]:
empty }.
6.2.6 프로퍼티 디스크립터 명세 타입
Property Descriptor 타입은 객체 프로퍼티 속성의 조작 및
구체화(reification)를 설명하는 데 사용된다. Property Descriptor는 0개 이상의 필드를 가진 Record이며, 각 필드의 이름은 속성
이름이고 값은 6.1.7.1에 명시된 해당 속성 값이다. 이 명세 내에서 리터럴
Property Descriptor 레코드의 태그로 사용되는 스키마 이름은 “PropertyDescriptor”이다.
Property Descriptor 값은 특정 필드의 존재 또는 사용에 따라 데이터 프로퍼티 디스크립터와 접근자 프로퍼티 디스크립터로 더 분류될 수 있다. 데이터 프로퍼티
디스크립터는 [[Value]] 또는 [[Writable]]라는 이름의 필드가 포함된
것이다. 접근자 프로퍼티 디스크립터는 [[Get]] 또는 [[Set]]라는 이름의
필드가 포함된 것이다. 어떤 Property Descriptor도 [[Enumerable]]와 [[Configurable]]라는 이름의 필드를 가질 수 있다. Property Descriptor 값은 데이터 프로퍼티
디스크립터이면서 접근자 프로퍼티 디스크립터일 수는 없지만, 둘 다 아닐 수는 있다(이 경우 일반 프로퍼티 디스크립터이다). 완전히 채워진
Property Descriptor는 접근자 프로퍼티 디스크립터 또는 데이터 프로퍼티 디스크립터 중 하나이면서 표 3에 명시된 모든 해당 필드를 가진 것이다.
Property Descriptor 값을 다루기 위해 이 명세에서는 다음 추상 연산들이 사용된다:
6.2.6.1 IsAccessorDescriptor ( Desc )
추상 연산 IsAccessorDescriptor는 인수 Desc ( Property
Descriptor )를 받아 Boolean을 반환한다. 호출 시 다음 단계를 수행한다:
Desc에 [[Get]] 필드가 있으면 true를
반환한다.
Desc에 [[Set]] 필드가 있으면 true를
반환한다.
false를 반환한다.
6.2.6.2 IsDataDescriptor ( Desc )
추상 연산 IsDataDescriptor는 인수 Desc ( Property
Descriptor )를 받아 Boolean을 반환한다. 호출 시 다음 단계를 수행한다:
Desc에 [[Value]] 필드가 있으면 true를
반환한다.
Desc에 [[Writable]] 필드가 있으면
true를 반환한다.
false를 반환한다.
6.2.6.3 IsGenericDescriptor ( Desc )
추상 연산 IsGenericDescriptor는 인수 Desc ( Property
Descriptor )를 받아 Boolean을 반환한다. 호출 시 다음 단계를 수행한다:
Desc에 [[Value]] 필드가 없으면
Desc.[[Value]]를 like.[[Value]]로 설정한다.
Desc에 [[Writable]] 필드가 없으면
Desc.[[Writable]]를 like.[[Writable]]로 설정한다.
그 외의 경우,
Desc에 [[Get]] 필드가 없으면
Desc.[[Get]]를 like.[[Get]]로 설정한다.
Desc에 [[Set]] 필드가 없으면
Desc.[[Set]]를 like.[[Set]]로 설정한다.
Desc에 [[Enumerable]] 필드가 없으면
Desc.[[Enumerable]]를 like.[[Enumerable]]로 설정한다.
Desc에 [[Configurable]] 필드가 없으면
Desc.[[Configurable]]를 like.[[Configurable]]로 설정한다.
unused를 반환한다.
6.2.7 환경 레코드 명세 타입
Environment Record 타입은 중첩 함수와 블록에서의 이름 해석
동작을 설명하는 데 사용된다. 이 타입과 그에 대한 연산들은 9.1에 정의되어 있다.
6.2.8 추상 클로저 명세 타입
Abstract Closure 명세 타입은 알고리즘 단계와 값들의 집합을 함께
참조하는 데 사용된다. Abstract Closure는 메타값이며, closure(arg1, arg2)와 같은
함수 호출 방식으로 호출된다. 추상
연산과 마찬가지로, 호출 시 Abstract Closure에 명시된 알고리즘 단계를 수행한다.
Abstract Closure를 생성하는 알고리즘 단계에서는 "capture"라는 동사 뒤에 별칭(alias) 목록을 사용해 값을 캡처한다. Abstract Closure가
생성될 때, 각 별칭에 연결된 값을 그 시점에 캡처한다. Abstract Closure가 호출될 때 수행할 알고리즘을 명시하는 단계에서는, 캡처된 각 값은 해당 별칭을 통해
참조된다.
Data Block 명세 타입은 구분되는 변경 가능한 바이트 크기(8비트) 정수 값들의
시퀀스를 설명하는 데 사용된다. byte value는 정수이며, 구간 [0,
255]에 속한다. Data Block 값은 고정된 개수의 바이트로 생성되며, 각 바이트의 초기값은 0이다.
이 명세 내 표기상의 편의를 위해, 배열과 유사한 문법을 사용해 Data Block 값의 개별 바이트에 접근할 수 있다. 이 표기법은 Data Block 값을 0부터 시작하는
정수-인덱스 바이트 시퀀스로 나타낸다. 예를 들어, db가 5바이트 Data Block 값이면
db[2]는 세 번째 바이트를 의미한다.
여러 agent에서 동시에 참조할 수 있는
메모리에 위치한 데이터 블록은 Shared Data Block으로
지정된다. Shared Data Block은 정체성(동등성 판단 목적)을 주소와 무관하게 가진다: 이는 프로세스의 가상 주소가 아니라 그 블록이 대표하는
메모리 위치 집합에 묶여 있다. 두 데이터 블록이 동일하다는 것은 그들이 포함하는 위치 집합이 동일할 때뿐이다. 그렇지 않으면 서로 다르며, 각자 위치 집합의 교집합은
없다. 마지막으로 Shared Data Block은 일반 Data Block과 구별된다.
PrivateElement 타입은 private 클래스 필드, 메서드, 접근자의 명세에 사용되는 Record이다. Property Descriptor는
private 요소에 사용되지 않지만, private 필드는 비구성, 비열거, 쓰기 가능한 데이터 프로퍼티와 유사하게 동작하고, private 메서드는
비구성, 비열거, 쓰기 불가능한 데이터 프로퍼티와 유사하며, private 접근자는 비구성, 비열거 접근자 프로퍼티와
유사하게 동작한다.
PrivateElement 타입의 값은 Record 값이며, 그 필드는
표 9에 정의되어 있다. 이러한 값은 PrivateElements라 한다.
Private Name 명세 타입은 전역적으로 고유한 값(다른 Private
Name과 구분되는 값, 비록 외견상 구별이 불가능하더라도)으로, private 클래스 요소(필드, 메서드, 접근자)의 키를 나타내는 데 사용된다. 각 Private
Name은 불변의 [[Description]]을 가지며, 이는 문자열 값이다. Private Name은
PrivateFieldAdd 또는 PrivateMethodOrAccessorAdd로 어떤
ECMAScript 객체에도 설치할 수 있으며, PrivateGet과 PrivateSet을 사용해 읽거나 쓸 수 있다.
6.2.13 ClassStaticBlockDefinition 레코드 명세 타입
ClassStaticBlockDefinition
Record는 클래스 정적 초기화 블록의 실행 가능한 코드를 캡슐화하는 데 사용되는 Record 값이다.
ClassStaticBlockDefinition Record는 표 11에 나열된 필드를 가진다.
이 연산들은 ECMAScript 언어의 일부가 아니며, 오직 ECMAScript 언어 의미의 명세를 돕기 위해 여기에 정의되어 있다. 다른, 더 특화된 추상 연산들은 이 명세 전반에 걸쳐 정의되어
있다.
7.1 타입 변환
ECMAScript 언어는 필요에 따라 암시적으로 자동 타입 변환을 수행한다. 특정 구문의 의미를 명확히 하기 위해 일련의 변환 추상 연산을 정의하는 것이 유용하다.
변환 추상 연산들은 다형적이며, 어떤
ECMAScript 언어 타입의 값도 인수로 받을 수 있다.
하지만 다른 명세 타입은 이 연산들과 함께 사용되지 않는다.
BigInt 타입은 ECMAScript 언어에서
암시적 변환을 가지지 않는다. 프로그래머는 다른 타입의 값을 변환하려면 BigInt를 명시적으로 호출해야 한다.
7.1.1 ToPrimitive ( input [ , preferredType ]
)
추상 연산 ToPrimitive는 인수 input (ECMAScript 언어 값)과 선택적
인수 preferredType (string 또는
number)을 받아, 특정 값을 포함하는 정상
완료ECMAScript 언어 값 또는 throw 완료를 반환한다. 이 연산은
input 인수를 Object 타입이 아닌 값으로 변환한다. 만약 객체가 둘 이상의 원시 타입으로 변환
가능하다면, 선택적 힌트 preferredType을 사용해 그 타입을 우선시할 수 있다. 호출 시 다음 단계를 수행한다:
ToPrimitive가 힌트 없이 호출될 때 기본적으로 number 힌트로 동작한다. 그러나 객체는 %Symbol.toPrimitive% 메서드를 정의함으로써 이
동작을 오버라이드할 수 있다. 이 명세에서 정의된 객체 중 Date( 21.4.4.45 참고 )와
Symbol 객체( 20.4.3.5 참고 )만이
기본 ToPrimitive 동작을 오버라이드한다. Date는 힌트가 없을 때 string으로 동작한다.
추상 연산 ToNumeric은 인수 value (ECMAScript 언어 값)를 받아,
특정 값을 포함하는 정상 완료 Number
또는 BigInt, 또는 throw 완료를 반환한다. 이 연산은
value를 Number 또는 BigInt로 변환해 반환한다. 호출 시 다음 단계를 수행한다:
추상 연산 RoundMVResult는 인수 n(수학적 값)을 받아 Number를 반환한다.
이 연산은 n을 구현 정의 방식으로 Number로 변환한다. 이 추상
연산에서, 숫자는 0이 아니거나 왼쪽에 0이 아닌 숫자가 있고 오른쪽에도 0이 아닌 숫자가 있을 때 유효 숫자(significant)로 간주한다. 이 추상
연산에서, "수학적 값이 나타내는" 어떤 수학적
값의 표현은 "수학적 값의 10진수 표현"의 역이다. 호출 시 다음 단계를
수행한다:
추상 연산 ToIntegerOrInfinity는 인수 argument (ECMAScript 언어 값)를 받아,
특정 값을 포함하는 정상 완료정수, +∞, 또는 -∞, 또는
throw 완료를 반환한다. 이 연산은
argument를 Number 값의 소수 부분을 잘라낸 정수로 변환하거나, 해당 Number 값이 무한대일 경우 +∞ 또는 -∞로 변환한다. 호출 시 다음
단계를 수행한다:
다른 대부분의 ECMAScript 정수 변환 연산과 달리, ToUint8Clamp는 소수 값을 절단(truncate)하지
않고 반올림(round)한다. 또한 "홀수 올림(round half up)"이 아닌 "짝수 쪽으로 반올림(round half to even)" 타이브레이킹을
사용한다. 이는 Math.round와 다르다.
7.1.13 ToBigInt ( argument )
추상 연산 ToBigInt는 인수 argument (ECMAScript 언어 값)를 받아,
특정 값을 포함하는 정상 완료 BigInt
또는 throw 완료를 반환한다. 이 연산은
argument를 BigInt 값으로 변환하거나, Number로의 암시적 변환이 필요한 경우 예외를 던진다. 호출 시 다음 단계를 수행한다:
추상 연산 CanonicalNumericIndexString는 인수 argument(문자열)를 받아 Number 또는
undefined를 반환한다. argument가 "-0"이거나 어떤 Number 값
n에 대해 ToString(n)과 정확히 일치하면, 해당 Number 값을 반환한다.
그렇지 않으면 undefined를 반환한다. 호출 시 다음 단계를 수행한다:
argument가 [[RegExpMatcher]] 내부 슬롯을 가지고 있으면
true를 반환한다.
false를 반환한다.
7.2.7 정적 의미: IsStringWellFormedUnicode (
string )
추상 연산 IsStringWellFormedUnicode는 인수 string(문자열)을 받아 Boolean을 반환한다. string을
6.1.4에서 설명된 대로 UTF-16
인코딩 코드 포인트의 시퀀스로 해석하고, 이것이 well formed한
UTF-16 시퀀스인지 판단한다. 호출 시 다음 단계를 수행한다:
추상 연산 IsLessThan은 인수 x(ECMAScript 언어 값),
y(ECMAScript 언어 값),
LeftFirst(Boolean)을 받아,
특정 값을 포함하는 정상 완료 Boolean
또는 undefined, 또는 throw 완료를
반환한다. 이 연산은 비교 x < y의 의미를 제공하며, true,
false, undefined(피연산자 중 하나 이상이 NaN인
경우)을 반환한다. LeftFirst 플래그는 x와 y에 부수 효과가 있을 수 있을 때 연산의 순서를 제어하는 데
사용된다. 호출 시 다음 단계를 수행한다:
3 단계는 1.c ( 13.15.3 )에서 논리합 대신
논리곱을 사용한다는 점에서 다르다.
참고 2
문자열의 비교는 UTF-16 코드 유닛의 시퀀스에 대한 단순한 사전식(lexicographic) 정렬을 사용한다. 유니코드 명세에 정의된 문자/문자열 동등성 및
정렬 순서의 더 복잡하고 의미론적인 정의는 사용하지 않는다. 따라서 유니코드 표준에서 정규적으로 동등하지만 정규화 형식이 다른 String 값은 같지 않다고
판정될 수 있다. 또한, 코드 유닛 기준 사전식 정렬은 서러게이트 쌍이 포함된 문자열의 코드 포인트 기준 정렬과 다를 수 있다.
추상 연산 MakeBasicObject는 인수 internalSlotsList(내부 슬롯 이름의 List)를 받아 객체를 반환한다. 이는
일반
객체와 특수 객체를 포함하여 알고리즘적으로 생성되는 모든 ECMAScript 객체의 근원이다. 이는
모든 객체 생성에 사용되는 공통 단계를 분리하고 객체 생성을 중앙 집중화한다. 호출 시 다음 단계를 수행한다:
Assert: 호출자가
obj의 [[GetPrototypeOf]]와 [[SetPrototypeOf]] 필수 내부 메서드를 모두 재정의하지 않는 경우,
internalSlotsList는 [[Prototype]]을 포함한다.
Assert: 호출자가
obj의 [[SetPrototypeOf]], [[IsExtensible]], [[PreventExtensions]]
필수 내부 메서드를 모두 재정의하지 않는 경우, internalSlotsList는 [[Extensible]]을 포함한다.
internalSlotsList에 [[Extensible]]가 포함되어 있으면
obj.[[Extensible]]를 true로 설정한다.
obj를 반환한다.
참고
이 명세 내에서 특수
객체는 추상 연산
(ArrayCreate, BoundFunctionCreate 등)에서 먼저
MakeBasicObject를 호출해 기본 객체를 얻고, 그 후에 해당 객체의 일부 또는 전체 내부 메서드를 재정의함으로써 생성된다. 특수 객체 생성을
캡슐화하기 위해, 객체의 필수 내부 메서드는 이러한 연산 외부에서 변경되지 않는다.
추상 연산 Set은 인수 O(객체), P(프로퍼티 키), V(ECMAScript 언어 값),
Throw(Boolean)을 받아,
특정 값을 포함하는 정상 완료unused 또는 throw 완료를
반환한다. 이 연산은 객체의 특정 프로퍼티 값을 설정할 때 사용된다. V는 프로퍼티에 할당할 새 값이다. 호출 시 다음 단계를 수행한다:
이 추상 연산은 ECMAScript 언어의 할당 연산자로 생성된 프로퍼티와 동일한 기본 속성으로 프로퍼티를 생성한다. 일반적으로 프로퍼티는 이미 존재하지
않는다. 만약 존재하고 설정 불가이거나 O가 확장 가능하지 않다면, [[DefineOwnProperty]]는 false를 반환한다.
7.3.6 CreateDataPropertyOrThrow ( O, P,
V )
추상 연산 CreateDataPropertyOrThrow는 인수 O(객체), P(프로퍼티 키), V(ECMAScript 언어 값)를 받아,
특정 값을 포함하는 정상 완료unused 또는 throw 완료를
반환한다. 이 연산은 객체의 새로운 자기 프로퍼티를 생성하는 데 사용된다. 요청된 프로퍼티 갱신을 수행할 수 없으면 TypeError
예외를 던진다. 호출 시 다음 단계를 수행한다:
이 추상 연산은 ECMAScript 언어의 할당 연산자로 생성된 프로퍼티와 동일한 기본 속성으로 프로퍼티를 생성한다. 일반적으로 프로퍼티는 이미 존재하지
않는다. 만약 존재하고 설정 불가이거나 O가 확장 가능하지 않다면, [[DefineOwnProperty]]는 false를 반환하고, 이 연산은
TypeError 예외를 던진다.
7.3.7 CreateNonEnumerableDataPropertyOrThrow ( O,
P, V )
추상 연산 CreateNonEnumerableDataPropertyOrThrow는 인수 O(객체), P(프로퍼티 키),
V(ECMAScript 언어 값)를 받아
unused를 반환한다. 이 연산은 일반 객체의 새로운 비열거형 자기 프로퍼티를 생성하는 데 사용된다. 호출 시 다음 단계를
수행한다:
이 추상 연산은 ECMAScript 언어의 할당 연산자로 생성된 프로퍼티와 동일한 기본 속성으로 프로퍼티를 생성하지만, 열거형이 아니다. 일반적으로 프로퍼티는
이미 존재하지 않는다. 만약 존재한다면 DefinePropertyOrThrow가 정상적으로
완료됨이 보장된다.
7.3.8 DefinePropertyOrThrow ( O, P,
desc )
추상 연산 DefinePropertyOrThrow는 인수 O(객체), P(프로퍼티 키), desc(프로퍼티 디스크립터)를 받아,
특정 값을 포함하는 정상 완료unused 또는 throw 완료를
반환한다. 이 연산은 객체의 [[DefineOwnProperty]] 내부 메서드를 호출하여, 요청된 프로퍼티 갱신을 수행할 수
없을 경우 TypeError 예외를 던진다. 호출 시 다음 단계를 수행한다:
success를 ? O.[[DefineOwnProperty]](P, desc)로
한다.
success가 false이면 TypeError 예외를 throw한다.
unused를 반환한다.
7.3.9 DeletePropertyOrThrow ( O, P )
추상 연산 DeletePropertyOrThrow는 인수 O(객체), P(프로퍼티 키)를 받아,
특정 값을 포함하는 정상 완료unused 또는 throw 완료를
반환한다. 이 연산은 객체의 특정 자기 프로퍼티를 제거하는 데 사용된다. 해당 프로퍼티가 설정 불가라면 예외를 던진다. 호출 시 다음 단계를 수행한다:
추상 연산 HasProperty는 인수 O(객체), P(프로퍼티 키)를 받아,
특정 값을 포함하는 정상 완료 Boolean
또는 throw 완료를 반환한다. 이 연산은
객체에 지정된 프로퍼티
키의 프로퍼티가 존재하는지(자기 또는 상속 포함) 확인하는 데 사용된다. 호출 시 다음 단계를 수행한다:
? O.[[HasProperty]](P)를 반환한다.
7.3.12 HasOwnProperty ( O, P )
추상 연산 HasOwnProperty는 인수 O(객체), P(프로퍼티 키)를 받아,
특정 값을 포함하는 정상 완료 Boolean
또는 throw 완료를 반환한다. 이 연산은
객체에 지정된 프로퍼티
키의 자기 프로퍼티가 존재하는지 확인하는 데 사용된다. 호출 시 다음 단계를 수행한다:
추상 연산 Construct는 인수 F(생성자)와 선택적 인수 argumentsList(List의 ECMAScript 언어 값),
newTarget(생성자)를 받아,
특정 값을 포함하는 정상 완료 객체 또는
throw 완료를 반환한다. 이 연산은
함수
객체의 [[Construct]] 내부 메서드를 호출하는 데 사용된다.
argumentsList와 newTarget는 내부 메서드의 해당 인수로 전달되는 값이다.
argumentsList가 없으면 새로운 빈 List가 사용된다.
newTarget가 없으면 F가 사용된다. 호출 시 다음 단계를 수행한다:
newTarget가 없으면 newTarget를 F로 설정한다.
argumentsList가 없으면 argumentsList를 새로운 빈 List로 설정한다.
추상 연산 SetIntegrityLevel은 인수 O(객체), level(sealed 또는
frozen)를 받아,
특정 값을 포함하는 정상 완료 Boolean
또는 throw 완료를 반환한다. 이 연산은
객체의 자기 프로퍼티 집합을 고정하는 데 사용된다. 호출 시 다음 단계를 수행한다:
status를 ? O.[[PreventExtensions]]()로
한다.
status가 false이면 false를 반환한다.
keys를 ? O.[[OwnPropertyKeys]]()로 한다.
level이 sealed이면,
keys의 각 요소 k에 대해, 다음을 수행한다:
? DefinePropertyOrThrow(O,
k, PropertyDescriptor { [[Configurable]]:
false })를 수행한다.
추상 연산 TestIntegrityLevel은 인수 O(객체), level(sealed 또는
frozen)를 받아,
특정 값을 포함하는 정상 완료 Boolean
또는 throw 완료를 반환한다. 이 연산은
객체의 자기 프로퍼티 집합이 고정되어 있는지 판단하는 데 사용된다. 호출 시 다음 단계를 수행한다:
추상 연산 CreateListFromArrayLike는 인수 obj(ECMAScript 언어 값)와 선택적
인수 validElementTypes(all 또는
property-key)를 받아,
정상 완료List (요소는 ECMAScript 언어 값) 또는 throw 완료를 반환한다. 이 연산은
obj의 인덱스 프로퍼티로부터 제공되는 요소들로 구성된 List 값을 생성하는 데 사용된다.
validElementTypes는 요소로 허용되는 값의 타입을 나타낸다. 호출 시 다음 단계를 수행한다:
추상 연산 OrdinaryHasInstance는 인수 C(ECMAScript 언어 값),
O(ECMAScript 언어 값)를 받아,
정상 완료 Boolean 또는
throw 완료를 반환한다. 이 연산은
O가 C가 제공하는 인스턴스 객체 상속 경로에서 상속받는지의 기본 알고리즘을 구현한다. 호출 시 다음 단계를 수행한다:
7.3.22 SpeciesConstructor ( O,
defaultConstructor )
추상 연산 SpeciesConstructor는 인수 O(객체), defaultConstructor(생성자)를 받아,
정상 완료로 생성자 또는 throw 완료를 반환한다. 이 연산은
O로부터 파생된 새 객체를 생성하는 데 사용할 생성자를 검색하는 데 사용된다. defaultConstructor는
O에서 생성자%Symbol.species% 프로퍼티를 찾을 수
없을 때 사용된다. 호출 시 다음 단계를 수행한다:
추상 연산 GetIteratorFlattenable는 인수 obj(ECMAScript 언어 값),
primitiveHandling(iterate-string-primitives 또는
reject-primitives)를 받아,
정상 완료로 반복자
레코드 또는 throw 완료를
반환한다. 호출 시 다음 단계를 수행한다:
추상 연산 IteratorStep은 인수 iteratorRecord(반복자 레코드)를 받아,
정상 완료 객체 또는
done, 또는 throw 완료를
반환한다. iteratorRecord.[[Iterator]]의
iteratorRecord.[[NextMethod]]를 호출하여 다음 값을 요청하고, 끝에 도달하면
done를 반환하며, 다음 값이 있으면 IteratorResult 객체를
반환한다. 호출 시 다음 단계를 수행한다:
추상 연산 IteratorStepValue는 인수 iteratorRecord(반복자 레코드)를 받아,
정상 완료ECMAScript 언어 값 또는
done, 또는 throw 완료를
반환한다. iteratorRecord.[[Iterator]]의
iteratorRecord.[[NextMethod]]를 호출하여 다음 값을 요청하고, 끝에 도달하면
done를 반환하며, 다음 값이 있으면 그 값을 반환한다. 호출 시 다음 단계를 수행한다:
추상 연산 CreateListIteratorRecord는 인수 list(ECMAScript 언어 값의 List)를
받아,
반복자
레코드를 반환한다. 이 연산은 [[NextMethod]]가
list의 요소를 차례로 반환하는 반복자 레코드를 생성한다. 호출 시 다음 단계를 수행한다:
closure를 인수가 없고 list를 캡처하는 새로운 Abstract
Closure로 한다. 호출 시 다음 단계를 수행한다:
"*default*"는 이 명세 내에서, 별도의 이름이 없는 모듈의 기본 내보내기(default export)에 대한
합성
이름으로 사용된다. 해당 이름으로 모듈의 [[Environment]]에 항목이 생성되고, 해당 값이
보관된다.
ResolveExport ( exportName [ ,
resolveSet ] )를 호출해 "default"라는
내보내기를 해석하면, [[BindingName]]이
"*default*"인
ResolvedBinding Record를 반환하게
되며,
이는 모듈의 [[Environment]]에서 위에서 언급한 값으로 해석된다. 이는 명세의 편의를 위해서만
이루어지며, 익명 기본 내보내기 또한 다른 내보내기와 동일하게 해석할 수 있도록 한다. 이 "*default*"
문자열은
ECMAScript 코드나 모듈 연결 알고리즘에서는 접근할 수 없다.
environment에 undefined가 전달되는 것은 초기화 값을 할당할 때 PutValue
연산을
사용해야 함을 나타낸다. 이는 var 문과 일부 비엄격 함수의 명시적 매개변수
목록(자세한
내용은 10.2.11 참고)에
해당한다.
이런 경우 렉시컬 바인딩이 호이스팅되고, 초기화식이 평가되기 전에 미리 초기화된다.
environment에 undefined가 전달될 경우, 초기화 값 할당에 PutValue
연산을
사용해야 함을 나타낸다. 이는 비엄격 함수의 명시적 매개변수 목록에 해당한다. 이 경우
동일한
이름의 매개변수가 여러 개 있을 수 있으므로, 명시적 매개변수 바인딩을 미리 초기화한다.
Environment Record는 ECMAScript 코드의 렉시컬 중첩
구조에
기반하여 Identifier들을 특정 변수와 함수에
연관시키기
위해 사용되는 명세 타입입니다. 보통 환경 레코드는 FunctionDeclaration, BlockStatement, 또는 Catch 절과 같이 ECMAScript 코드의 특정 구문 구조와
연결됩니다.
이와 같은 코드가 평가될 때마다, 해당 코드가 생성하는 식별자 바인딩을 기록하기 위해 새로운 환경 레코드가 생성됩니다.
모든 환경 레코드는 [[OuterEnv]] 필드를 가지며, 이 값은 null이거나 외부 환경
레코드를
참조합니다. 이 필드는 환경 레코드 값들의 논리적 중첩 구조를 모델링하는 데 사용됩니다. (내부) 환경 레코드의 외부 참조는 논리적으로 그 내부 환경 레코드를 둘러싸는 환경
레코드를 참조합니다. 외부 환경 레코드는 물론 그 자체로 또 다른 외부 환경 레코드를 가질 수 있습니다. 하나의 환경 레코드는 여러 내부 환경 레코드의 외부 환경이 될 수
있습니다. 예를 들어, FunctionDeclaration이 두 개의 중첩된 FunctionDeclaration을 포함한다면,
각
중첩 함수의 환경 레코드는 현재 평가 중인 외부 함수의 환경 레코드를 외부 환경 레코드로 갖게 됩니다.
환경 레코드는 오직 명세상의 메커니즘일 뿐이며, ECMAScript 구현의 어떤 특정 산출물과 반드시 대응할 필요는 없습니다. ECMAScript 프로그램이 이러한 값을
직접적으로
접근하거나 조작하는 것은 불가능합니다.
객체 환경
레코드는 WithStatement 등과 같이 식별자 바인딩을
어떤
객체의 프로퍼티와 연결하는 ECMAScript 요소의 효과를 정의하는 데 사용됩니다.
전역 환경
레코드는 Script의 전역 선언에 사용됩니다. 이 레코드는 외부 환경을
가지지
않으며, 그 [[OuterEnv]]는 null입니다. 미리
식별자
바인딩이 채워져 있을 수 있으며, 글로벌 객체와 연관되어 있어, 그 프로퍼티들이
전역
환경의 일부 식별자 바인딩을 제공합니다. ECMAScript 코드가 실행됨에 따라 글로벌
객체에 프로퍼티가 추가될 수 있고, 초기 프로퍼티들이 수정될 수도 있습니다.
환경
레코드 추상 클래스에는 표 16에 정의된 추상 명세
메서드가 포함되어 있습니다. 이 추상 메서드들은 각 구체적 하위 클래스마다 서로 다른 구체적 알고리즘을 가집니다.
환경 레코드가 문자열 값
N에 대한 바인딩을 가지고 있는지 확인합니다. 가지고 있다면 true를,
아니라면
false를 반환합니다.
CreateMutableBinding(N, D)
환경 레코드에 새로운(아직
초기화되지
않은) 변경 가능한 바인딩을 생성합니다. 문자열 값 N은 바인딩될 이름의 텍스트입니다. 불리언 인자
D가 true라면, 이 바인딩은 이후 삭제될 수 있습니다.
CreateImmutableBinding(N, S)
환경 레코드에 새로운(아직
초기화되지
않은) 변경 불가능한 바인딩을 생성합니다. 문자열 값 N은 바인딩될 이름의 텍스트입니다.
S가
true라면, 초기화 후 값을 설정하려는 시도는 엄격 모드 여부와 관계없이 항상 예외를
발생시킵니다.
InitializeBinding(N, V)
환경 레코드에 이미 존재하지만
아직
초기화되지 않은 바인딩의 값을 설정합니다. 문자열 값 N은 바인딩될 이름의 텍스트입니다.
V는
바인딩에 대한 값이며, ECMAScript
언어
타입의 값입니다.
SetMutableBinding(N, V, S)
환경 레코드에 이미 존재하는
변경
가능한 바인딩의 값을 설정합니다. 문자열 값 N은 바인딩될 이름의 텍스트입니다. V는
바인딩에
대한 값이며, ECMAScript
언어
타입의 값일 수 있습니다. S는 불리언
플래그입니다. S가 true이며 바인딩에 값을 설정할 수 없으면
TypeError 예외를 발생시킵니다.
GetBindingValue(N, S)
환경 레코드에서 이미 존재하는
바인딩의
값을 반환합니다. 문자열 값 N은 바인딩될 이름의 텍스트입니다. S는 엄격 모드 코드에서 시작되었거나 엄격
모드
참조语 의미가 요구되는 참조를 식별하는 데 사용됩니다. S가 true이고
바인딩이
존재하지 않으면 ReferenceError 예외를 발생시킵니다. 바인딩이 존재하지만 초기화되지
않았다면
S의 값과 상관없이 ReferenceError가 발생합니다.
DeleteBinding(N)
환경 레코드에서 바인딩을
삭제합니다.
문자열 값 N은 바인딩될 이름의 텍스트입니다. N에 대한 바인딩이 존재하면 해당 바인딩을
제거하고
true를 반환합니다. 바인딩이 존재하나 삭제할 수 없는 경우
false를 반환합니다. 바인딩이 존재하지 않으면 true를
반환합니다.
HasThisBinding()
환경 레코드가
this 바인딩을 설정하는지 확인합니다. 그렇다면 true, 아니라면
false를 반환합니다.
HasSuperBinding()
환경 레코드가
super 메서드 바인딩을 설정하는지 확인합니다. 그렇다면 true,
아니라면
false를 반환합니다. true를 반환한다면
환경 레코드가 함수 환경
레코드임을
의미하지만, 그 역은 성립하지 않습니다.
WithBaseObject()
이 환경 레코드가
with 문과 연관되어 있다면, with 객체를 반환합니다. 그렇지 않으면
undefined를 반환합니다.
9.1.1.1 선언적 환경 레코드
각 선언적 환경 레코드는 변수, 상수,
let, class, module, import, 그리고/또는 함수 선언을 포함하는 ECMAScript 프로그램 스코프와 연관되어 있습니다. 선언적 환경
레코드는 그
스코프 내에 포함된 선언들이 정의하는 식별자 집합을 바인딩합니다.
9.1.1.1.1 HasBinding ( N )
선언적 환경 레코드envRec의 HasBinding 구체 메서드는 N (문자열)을 인자로 받아 불리언을 포함하는 정상
완료를
반환합니다. 이 메서드는 인자로 받은 식별자가 레코드에 바인딩된 식별자 중 하나인지 판단합니다. 호출 시 다음 단계를 수행합니다:
envRec가 N에 대한 바인딩을 가지고 있다면 true를
반환한다.
false를 반환한다.
9.1.1.1.2 CreateMutableBinding ( N,
D
)
선언적 환경 레코드envRec의 CreateMutableBinding 구체 메서드는 N (문자열)과 D
(불리언)를
인자로 받아 unused를 포함하는 정상
완료를 반환합니다. 이름 N에 대해 초기화되지 않은 새로운 변경 가능한 바인딩을
생성합니다. 이
환경 레코드 내에 N에 대한
바인딩이
이미 존재해서는 안 됩니다. D가 true이면, 새로 생성된 바인딩은 삭제 대상임이 표시됩니다.
호출 시
다음 단계를 수행합니다:
envRec에 대해 N에 대한 변경 가능한 바인딩을 생성하고, 초기화되지 않았음을 기록한다.
D가 true이면, 새로 생성된 바인딩이 이후 DeleteBinding 호출로
삭제될 수
있음을 기록한다.
unused를 반환한다.
9.1.1.1.3 CreateImmutableBinding ( N,
S )
선언적 환경 레코드envRec의 CreateImmutableBinding 구체 메서드는 N (문자열)과 S
(불리언)를 인자로 받아 unused를 포함하는
정상
완료를 반환합니다. 이름 N에 대해 초기화되지 않은 새로운 변경 불가능한 바인딩을
생성합니다. 이
환경 레코드 내에 N에 대한
바인딩이
이미 존재해서는 안 됩니다. S가 true이면, 새로 생성된 바인딩이 strict 바인딩임을
표시합니다.
호출 시 다음 단계를 수행합니다:
envRec에 대해 N에 대한 변경 불가능한 바인딩을 생성하고, 초기화되지 않았음을 기록한다.
S가 true이면, 새로 생성된 바인딩이 strict 바인딩임을 기록한다.
unused를 반환한다.
9.1.1.1.4 InitializeBinding ( N, V
)
선언적 환경 레코드envRec의 InitializeBinding 구체 메서드는 N (문자열)과 V
(ECMAScript 언어 값)를 인자로
받아
unused를 포함하는 정상
완료를 반환합니다. 이 메서드는 이름이 N인 식별자의 현재 바인딩의 값을
V로
설정합니다. N에 대한 초기화되지 않은 바인딩이 이미 존재해야 합니다. 호출 시 다음 단계를 수행합니다:
선언적 환경 레코드envRec의 SetMutableBinding 구체 메서드는 N (문자열), V
(ECMAScript 언어 값),
S (불리언)를 인자로 받아 unused를 포함하는 정상
완료 또는 throw
completion을 반환합니다. 이 메서드는 이름이 N인 식별자의 현재 바인딩의 값을
V로 변경하려고 시도합니다. N에 대한 바인딩이 보통 이미 존재하지만, 드물게 존재하지 않을 수도 있습니다.
바인딩이
변경 불가능한 경우 S가 true이면 TypeError를
발생시킵니다.
호출 시 다음 단계를 수행합니다:
다음과 같은 ECMAScript 코드는 1 단계에서
바인딩이 존재하지 않게 되는 결과를 초래할 수 있습니다:
functionf() { eval("var x; x = (delete x, 0);"); }
9.1.1.1.6 GetBindingValue ( N, S )
선언적 환경 레코드envRec의 GetBindingValue 구체 메서드는 N (문자열)과 S (불리언)를
인자로
받아 ECMAScript 언어 값을 포함하는 정상
완료 또는 throw
completion을 반환합니다. 이 메서드는 이름이 N인 바인딩된 식별자의 값을
반환합니다.
바인딩이 존재하지만 아직 초기화되지 않았다면 S 값과 무관하게 ReferenceError 예외가
발생합니다. 호출 시 다음 단계를 수행합니다:
선언적 환경 레코드envRec의 WithBaseObject 구체 메서드는 인자가 없으며 undefined를
반환합니다.
호출 시 다음 단계를 수행합니다:
undefined를 반환한다.
9.1.1.2 객체 환경 레코드
각 객체 환경 레코드는 자신의 바인딩
객체라 불리는 객체와 연관되어 있습니다. 객체 환경 레코드는 바인딩 객체의 프로퍼티 이름에 직접적으로 대응하는 문자열 식별자 이름 집합을
바인딩합니다. 프로퍼티
키 중 IdentifierName 형태의 문자열이 아닌 것들은 바인딩된 식별자
집합에
포함되지 않습니다. 자신의 [[Enumerable]] 특성 설정과 상관없이 소유 및 상속된 프로퍼티 모두 집합에
포함됩니다. 객체에 프로퍼티가 동적으로 추가되거나 삭제될 수 있기 때문에, 객체 환경 레코드에 바인딩된 식별자 집합은 프로퍼티 추가/삭제 연산의 부수 효과로
잠재적으로 변경될 수 있습니다. 이런 부수 효과로 생성된 모든 바인딩은 해당 프로퍼티의 Writable 특성이
false이어도 변경
가능한 바인딩으로 간주합니다. 객체 환경 레코드에는 변경 불가능한(immutable) 바인딩이 존재하지 않습니다.
with 문(14.11)을 위해 생성된 객체 환경 레코드는 바인딩 객체를 함수
호출에서
암시적 this 값으로 제공할 수 있습니다. 이 기능은 불리언 타입의 [[IsWithEnvironment]] 필드로 제어됩니다.
객체 환경 레코드envRec의 HasBinding 구체 메서드는 N (문자열)을 인자로 받아 불리언을 포함하는 정상
완료
또는 throw
completion을 반환합니다. 이 메서드는 연관된 바인딩 객체에 N이라는 이름의
프로퍼티가
존재하는지 판단합니다. 호출 시 다음 단계를 수행합니다:
bindingObject를 envRec.[[BindingObject]]로 둔다.
foundBinding를 ? HasProperty(bindingObject,
N)로 둔다.
객체 환경 레코드envRec의 CreateMutableBinding 구체 메서드는 N (문자열)과 D
(불리언)를
인자로 받아 unused를 포함하는 정상
완료 또는 throw
completion을 반환합니다. 이 메서드는 환경
레코드와 연관된 바인딩 객체에 N이라는 이름의 프로퍼티를 생성하고, 그 값을
undefined로 초기화합니다. D가 true면 새 프로퍼티의
[[Configurable]] 특성을 true로, 아니면
false로 설정합니다. 호출 시 다음 단계를 수행합니다:
bindingObject를 envRec.[[BindingObject]]로 둔다.
? DefinePropertyOrThrow(bindingObject,
N, PropertyDescriptor { [[Value]]:
undefined, [[Writable]]:
true, [[Enumerable]]:
true, [[Configurable]]:
D })를 수행한다.
unused를 반환한다.
참고
보통 envRec는 N에 대한 바인딩을 갖지 않지만, 만약 갖고 있다면 DefinePropertyOrThrow의
의미론에 따라 기존 바인딩이 대체되거나 가려지거나, 비정상
완료가
반환될 수 있습니다.
9.1.1.2.3 CreateImmutableBinding ( N,
S )
객체 환경 레코드의
CreateImmutableBinding 구체 메서드는 이 명세 안에서 사용되지 않습니다.
이 명세에서 객체 환경 레코드에 대한 CreateMutableBinding의 모든 사용은 곧바로 같은 이름에 대해
InitializeBinding을 호출합니다. 따라서 이 명세는 객체 환경 레코드의 바인딩
초기화
상태를 명시적으로 추적하지 않습니다.
9.1.1.2.5 SetMutableBinding ( N,
V,
S )
객체 환경 레코드envRec의 SetMutableBinding 구체 메서드는 N (문자열), V
(ECMAScript 언어 값),
S (불리언)를 인자로 받아 unused를 포함하는 정상
완료 또는 throw
completion을 반환합니다. 이 메서드는 환경
레코드와 연관된 바인딩 객체의 N이라는 이름의 프로퍼티 값을 V로
설정하려고
시도합니다. N이라는 이름의 프로퍼티가 보통 이미 존재하지만, 존재하지 않거나 쓰기 불가능한 경우 오류 처리는
S에
따라 결정됩니다. 호출 시 다음 단계를 수행합니다:
객체 환경 레코드envRec의 GetBindingValue 구체 메서드는 N (문자열)과 S (불리언)를
인자로
받아 ECMAScript 언어 값을 포함하는 정상
완료 또는 throw
completion을 반환합니다. 이 메서드는 연관된 바인딩 객체의 N 이름의 프로퍼티
값을
반환합니다. 프로퍼티는 이미 존재해야 하지만, 존재하지 않을 경우 결과는 S에 따라 달라집니다. 호출 시 다음 단계를 수행합니다:
객체 환경 레코드envRec의 DeleteBinding 구체 메서드는 N (문자열)을 인자로 받아 불리언을 포함하는 정상
완료
또는 throw
completion을 반환합니다. 이 메서드는 환경 객체의 [[Configurable]] 특성이 true인 프로퍼티에 대응되는
바인딩만
삭제할 수 있습니다. 호출 시 다음 단계를 수행합니다:
bindingObject를 envRec.[[BindingObject]]로 둔다.
? bindingObject.[[Delete]](N)를 반환한다.
9.1.1.2.8 HasThisBinding ( )
객체 환경 레코드envRec의 HasThisBinding 구체 메서드는 인자가 없으며 false를 반환합니다.
호출 시
다음 단계를 수행합니다:
함수 환경 레코드는 선언적 환경 레코드이며, 함수의 최상위
스코프를 표현하는 데 사용되고, 함수가 ArrowFunction이 아닐 경우 this
바인딩을
제공합니다. 함수가 ArrowFunction이
아니고 super를 참조한다면, 해당 함수 환경 레코드는 함수 내부에서 super 메서드 호출을 수행하는 데
사용되는
상태도 포함합니다.
추상 연산 GetSuperBase는 envRec (함수 환경
레코드)를 인자로 받아 객체, null, 또는
undefined를 반환합니다. 이 연산은 envRec에 바인딩된
super
프로퍼티 접근의 기반이 되는 객체를 반환합니다. 값이 undefined이면, 그러한 접근이 런타임 오류를 발생시킴을
나타냅니다. 호출 시 다음 단계를 수행합니다:
home을 envRec.[[FunctionObject]].[[HomeObject]]로 둔다.
전역 환경 레코드는 공통 realm에서 처리되는 모든
ECMAScript
Script 요소가 공유하는 가장 바깥쪽 스코프를
나타내는
데 사용됩니다. 전역 환경 레코드는 내장 글로벌(19), 글로벌
객체의 프로퍼티, 그리고 Script 내에서 발생하는 모든 최상위 선언(8.2.9,
8.2.11)에
대한 바인딩을 제공합니다.
전역 환경 레코드envRec의 CreateMutableBinding 구체 메서드는 N (문자열)과 D
(불리언)를
인자로 받아 unused를 포함하는 정상
완료 또는 throw
completion을 반환합니다. 이름 N에 대해 초기화되지 않은 새로운 변경 가능한
바인딩을
생성합니다. 바인딩은 관련 DeclarativeRecord에 생성됩니다. DeclarativeRecord에 N에 대한 바인딩이 이미
존재해서는 안 됩니다. D가 true이면, 새로 생성된 바인딩은 삭제 대상임이 표시됩니다. 호출
시 다음
단계를 수행합니다:
전역 환경 레코드envRec의 CreateImmutableBinding 구체 메서드는 N (문자열)과 S
(불리언)를 인자로 받아 unused를 포함하는
정상
완료 또는 throw
completion을 반환합니다. 이름 N에 대해 초기화되지 않은 새로운 변경 불가능한
바인딩을
생성합니다. 이 환경 레코드 내에 N에 대한
바인딩이
이미 존재해서는 안 됩니다. S가 true이면, 새로 생성된 바인딩이 strict 바인딩임을
표시합니다.
호출 시 다음 단계를 수행합니다:
전역 환경 레코드envRec의 SetMutableBinding 구체 메서드는 N (문자열), V
(ECMAScript 언어 값),
S (불리언)를 인자로 받아 unused를 포함하는 정상
완료 또는 throw
completion을 반환합니다. 이 메서드는 이름이 N인 식별자의 현재 바인딩 값을
V로 변경하려고 시도합니다. 바인딩이 변경 불가능한 경우 S가 true이면
TypeError를 발생시킵니다. N이라는 이름의 프로퍼티가 보통 이미 존재하지만, 존재하지
않거나 쓰기
불가능한 경우 오류 처리는 S에 따라 결정됩니다. 호출 시 다음 단계를 수행합니다:
DclRec를 envRec.[[DeclarativeRecord]]로 둔다.
! DclRec.HasBinding(N)이
true라면,
? DclRec.SetMutableBinding(N,
V,
S)을 반환한다.
ObjRec를 envRec.[[ObjectRecord]]로
둔다.
? ObjRec.SetMutableBinding(N,
V, S)을 반환한다.
9.1.1.4.6 GetBindingValue ( N, S )
전역 환경 레코드envRec의 GetBindingValue 구체 메서드는 N (문자열)과 S (불리언)를
인자로
받아 ECMAScript 언어 값을 포함하는 정상
완료 또는 throw
completion을 반환합니다. 이 메서드는 이름이 N인 바인딩된 식별자의 값을
반환합니다.
바인딩이 초기화되지 않은 바인딩이면 ReferenceError 예외를 발생시킵니다. N이라는
이름의
프로퍼티가 보통 이미 존재하지만, 존재하지 않거나 쓰기 불가능한 경우 결과는 S에 따라 결정됩니다. 호출 시 다음 단계를
수행합니다:
추상 연산 HasLexicalDeclaration은 envRec (전역 환경 레코드)와
N
(문자열)을 인자로 받아 불리언을 반환합니다. 이 연산은 인자 식별자가 LexicalDeclaration 또는 ClassDeclaration과
같은
렉시컬 선언을 사용해 envRec에 바인딩되어 있는지 판단합니다. 호출 시 다음 단계를 수행합니다:
DclRec를 envRec.[[DeclarativeRecord]]로 둔다.
! DclRec.HasBinding(N)을 반환한다.
9.1.1.4.13 HasRestrictedGlobalProperty (
envRec,
N )
추상 연산 HasRestrictedGlobalProperty는 envRec (전역 환경 레코드)와
N
(문자열)을 인자로 받아 불리언을 포함하는 정상
완료 또는 throw
completion을 반환합니다. 이 연산은 인자 식별자가 글로벌
객체의 글로벌 렉시컬 바인딩에 의해 가려져서는 안 되는 프로퍼티 이름인지 판단합니다. 호출 시 다음 단계를
수행합니다:
ObjRec를 envRec.[[ObjectRecord]]로
둔다.
globalObject를 ObjRec.[[BindingObject]]로 둔다.
existingProp를 ? globalObject.[[GetOwnProperty]](N)로 둔다.
글로벌 객체에 var나 function 선언을
사용하지
않고 직접 생성된 프로퍼티가 존재할 수 있습니다. 글로벌 렉시컬 바인딩은 글로벌 객체의
non-configurable 프로퍼티와 같은 이름으로는 생성될 수 없습니다. "undefined"
글로벌
프로퍼티가 그 예입니다.
IsDataDescriptor(existingProp)가
true이고 existingProp의 특성 값이 { [[Writable]]: true, [[Enumerable]]: true }라면
true를 반환한다.
false를 반환한다.
9.1.1.4.16 CreateGlobalVarBinding ( envRec,
N, D )
추상 연산 CreateGlobalVarBinding은 envRec (전역 환경 레코드),
N
(문자열), D (불리언)를 인자로 받아, unused를 포함하는 정상
완료 또는 throw
completion을 반환합니다. 연관된 객체 환경 레코드에 변경 가능한 바인딩을
생성
및 초기화합니다. 바인딩이 이미 존재한다면 재사용하며, 이미 초기화된 것으로 간주합니다. 호출 시 다음 단계를 수행합니다:
전역 함수 선언은 항상 글로벌 객체의 own 프로퍼티로 표현됩니다.
가능할
경우, 기존 own 프로퍼티를 표준 특성 값 집합을 가지도록 재설정합니다. 7 단계는
InitializeBinding 구체 메서드를 호출하는 것과 동등하며, globalObject가 Proxy인 경우
동일한
Proxy trap 호출 시퀀스를 생성합니다.
9.1.1.5 모듈 환경 레코드
모듈 환경 레코드는 선언적 환경 레코드로,
ECMAScript
Module의 외부 스코프를 표현하는 데
사용됩니다.
일반적인 변경 가능/불변 바인딩 외에, 모듈 환경 레코드는 다른 환경 레코드에 존재하는 대상
바인딩에
간접적으로 접근할 수 있는 변경 불가능한 import 바인딩도 제공합니다.
모듈 환경 레코드는 선언적 환경 레코드의 모든
메서드(표 16 참조)를
지원하며,
GetBindingValue, DeleteBinding, HasThisBinding, GetThisBinding을 제외한 모든 메서드는 동일한 명세를
따릅니다.
또한, 모듈 환경 레코드는 표
22에 나열된 메서드들도 지원합니다:
모듈 환경 레코드envRec의 GetBindingValue 구체 메서드는 N (문자열), S (불리언)를
인자로
받아 ECMAScript 언어 값을 포함하는 정상
완료 또는 throw
completion을 반환합니다. 이 메서드는 이름이 N인 바인딩된 식별자의 값을
반환합니다.
단, 바인딩이 간접 바인딩인 경우 대상 바인딩의 값을 반환합니다. 바인딩이 존재하지만 아직 초기화되지 않았다면
ReferenceError가 발생합니다. 호출 시 다음 단계를 수행합니다:
9.1.1.5.5 CreateImportBinding ( envRec,
N, M, N2 )
추상 연산 CreateImportBinding은 envRec (모듈 환경 레코드),
N
(문자열), M (모듈 레코드), N2
(문자열)을
인자로 받아 unused를 반환합니다. N에 대해 초기화된 변경 불가능한 간접 바인딩을
새롭게
생성합니다. envRec 내에 이미 N에 대한 바인딩이 존재해서는 안 됩니다. N2는
M의 모듈 환경 레코드에 존재하는 바인딩의
이름입니다. 새 바인딩에 대한 값 접근은 간접적으로 대상 바인딩의 값을 접근합니다. 호출 시 다음 단계를 수행합니다:
평가되기 전에, 모든 ECMAScript 코드는 realm에 연관되어야
합니다.
개념적으로, realm은 일련의 내장 객체
집합,
ECMAScript 글로벌 환경, 그 글로벌 환경의 범위 내에서 로드된 모든 ECMAScript 코드, 기타 관련 상태와 리소스로 구성됩니다.
realmRec.[[Intrinsics]]의 각 필드를 표 6에 명시된 값들로 설정한다.
필드명은 표의 첫 번째 열에 기재된 이름이다. 각 필드의 값은, 이 명세의 각 객체 명세에 따라 완전히, 재귀적으로 프로퍼티 값이 채워진 새로운 객체
값이다.
모든 객체 프로퍼티 값은 새로 생성된 객체 값이어야 한다. 내장 함수 객체인 값은 CreateBuiltinFunction(steps,
length, name, slots, realmRec,
prototype)을 수행하여 생성한다. steps는 명세에 정의된 함수 정의, name은
함수의
"name" 프로퍼티 초기값, length는 "length"
초기값,
slots는 함수의 내부 슬롯명(있으면), prototype은 함수의 [[Prototype]] 내부 슬롯의 명세 값이다. intrinsic 및 그 프로퍼티 생성 순서는 아직
생성되지
않은 객체에 의존하지 않도록 해야 한다.
실행 컨텍스트는 ECMAScript 구현체가 코드의 런타임 평가를 추적하기
위해
사용하는 명세 장치입니다. 특정 시점에, 실제로 코드를 실행 중인 agent마다 최대 하나의 실행 컨텍스트만 존재할 수 있습니다. 이를 agent의 실행 중인 실행
컨텍스트라 합니다. 이 명세에서 실행 중인 실행
컨텍스트에 대한 모든 참조는 상위 agent의 실행 중인
실행
컨텍스트를 나타냅니다.
실행 컨텍스트
스택은
실행 컨텍스트들을 추적하는 데 사용됩니다. 실행 중인 실행 컨텍스트는 항상 이 스택의 맨 위 요소입니다. 현재
실행
중인 실행 컨텍스트와 연관된 실행 코드에서 아직 연관되지 않은 실행 코드로 제어가 이동할 때마다, 새 실행 컨텍스트가 생성되어
스택에
푸시되고 실행 중인 실행 컨텍스트가 됩니다.
실행 컨텍스트는 연관된 코드의 실행 진행을 추적하는 데 필요한 구현체 고유의 상태를 포함합니다. 각 실행 컨텍스트는 최소한 표 25에 나열된 상태 구성
요소를
가집니다.
대부분의 상황에서 이 명세 내 알고리즘이 직접 다루는 것은 실행 중인 실행 컨텍스트 (즉, 실행 컨텍스트
스택의 맨 위)입니다. 따라서 “LexicalEnvironment”, “VariableEnvironment”라는 용어가 한정 없이
사용될
때는 실행 중인 실행 컨텍스트의 해당 구성 요소를 의미합니다.
실행 컨텍스트는 순수 명세 메커니즘으로, ECMAScript 구현의 실제 산출물과 반드시 대응하지 않습니다. ECMAScript 코드가 실행 컨텍스트를 직접 접근하거나
관찰하는 것은
불가능합니다.
9.4.1 GetActiveScriptOrModule ( )
추상 연산 GetActiveScriptOrModule은 인자가 없으며, Script Record, Module Record 또는
null을 반환합니다. 실행 중인 실행 컨텍스트를 기반으로
현재 실행 중인 스크립트 또는
모듈을 결정하는 데 사용됩니다. 호출 시 다음 단계를 수행합니다:
JobCallback 레코드를 반환해야 하며, 그 [[Callback]] 필드는 callback이어야 한다.
HostMakeJobCallback의 기본 구현은 호출 시 다음 단계를 수행합니다:
JobCallback 레코드 { [[Callback]]: callback, [[HostDefined]]: empty }를 반환한다.
웹 브라우저가 아닌 ECMAScript 호스트는
HostMakeJobCallback의 기본 구현을 사용해야 합니다.
참고
이 연산은 콜백이 결국 예약·실행 책임이 있는 함수에 전달될 때 호출됩니다. 예를 들어
promise.then(thenAction)은
Promise.prototype.then을 호출할 때 thenAction에 대해
MakeJobCallback을
호출하며, 리액션 잡을
스케줄링할 때가
아닙니다.
웹 브라우저가 아닌 ECMAScript 호스트는
HostCallJobCallback의 기본 구현을 사용해야 합니다.
9.5.4 HostEnqueueGenericJob ( job, realm )
호스트 정의
추상 연산
HostEnqueueGenericJob은 job(잡추상 클로저),
realm(Realm
Record)를
인자로 받아 unused를 반환합니다. job을 realm이 소유한 에이전트의 realm에 예약합니다. 이 알고리즘에서 사용하는
추상
클로저는 우선순위나 순서 등 추가 제약 없이 예약되는 것을 의도합니다.
호스트 정의
추상 연산
HostEnqueuePromiseJob은 job(잡추상 클로저),
realm(Realm
Record 또는
null)를 인자로 받아 unused를 반환합니다. job을 미래의
어느
시점에 실행하도록 예약합니다. 이 알고리즘의 추상 클로저는 Promise 처리와 관련되거나 Promise 처리 연산과
같은
우선순위로 예약되는 것을 의도합니다.
HostEnqueuePromiseJob의 구현은 9.5의 요구사항과 다음을 따라야 합니다:
HostEnqueuePromiseJob이 호출될 때 GetActiveScriptOrModule()의 값을
scriptOrModule로 두고, realm이 null이 아니면
job이 호출될 때마다 scriptOrModule이 활성
스크립트 또는 모듈임을 보장하는 구현 정의 단계를 수행해야 한다.
호스트 정의
추상 연산
HostEnqueueTimeoutJob은 timeoutJob(잡추상 클로저),
realm(Realm
Record),
milliseconds(음이 아닌 유한 숫자)를 인자로 받아 unused를 반환합니다.
timeoutJob을 realm이 소유한 에이전트의 realm에서 최소 milliseconds 밀리초 후에 실행되도록 예약합니다.
초기값은 0이며, 비동기 또는 비동기 의존성이 있는 모듈의 [[AsyncEvaluationOrder]] 필드에 고유하게 증가하는 값을 할당하는 데
사용됩니다.
[[Signifier]], [[IsLockFree1]], [[IsLockFree2]]의 값은 에이전트 클러스터 내의 어떤 에이전트에라도 관찰되면 변경될 수 없습니다.
참고 2
[[IsLockFree1]]과 [[IsLockFree2]]의 값은
반드시
하드웨어에 의해 결정되는 것은 아니며, 구현 선택에 따라 시간 및 ECMAScript 구현별로 달라질 수 있습니다.
[[IsLockFree4]] 필드는 없습니다. 4바이트 원자 연산은 항상 lock-free입니다.
실제로, 원자 연산이 어떤 종류의 락을 사용한다면 lock-free가 아닙니다. lock-free는 wait-free와는 다릅니다. lock-free 원자
연산을
완료하는 데 필요한 머신 스텝 수에 상한이 없습니다.
크기 n의 원자 접근이 lock-free여도, 크기 n의 비원자 접근의 (관측된) 원자성에 대해서는 아무것도 보장하지 않습니다.
비원자
접근은 여전히 여러 번의 별도 메모리 접근으로 수행될 수 있습니다. 자세한 내용은 ReadSharedMemory 및
WriteSharedMemory를 참고하세요.
참고 3
에이전트는 명세 메커니즘일
뿐이며, 실제
ECMAScript 구현의 어떤 구체적 산출물과 반드시 대응하지는 않습니다.
9.6.1 AgentSignifier ( )
추상 연산 AgentSignifier는 인자가 없으며 에이전트 식별자를 반환합니다. 호출 시 다음 단계를 수행합니다:
클러스터 내의 에이전트가 항상
동시에
살아 있을 필요는 없습니다. 에이전트A가 또 다른 에이전트B를 생성한 뒤 A가 종료되고, B가 에이전트C를 생성했다고 합시다. 만약 A가 B와
메모리를
공유할 수 있고, B가 C와 메모리를 공유할 수 있다면, 세 에이전트는 같은 클러스터에 속합니다.
클러스터 내의 모든 에이전트는 각각의
에이전트 레코드의
[[LittleEndian]] 필드 값이 동일해야 합니다.
참고 3
에이전트 클러스터 내의 서로 다른 에이전트가 [[LittleEndian]] 값이
다르면,
멀티바이트 데이터의 공유 메모리 사용이 어려워집니다.
클러스터 내의 모든 에이전트는 각각의
에이전트 레코드의
[[IsLockFree1]] 필드 값이 동일해야 하며, [[IsLockFree2]]
필드도
마찬가지입니다.
클러스터 내의 모든 에이전트는 각각의
에이전트 레코드의
[[Signifier]] 값이 달라야 합니다.
임베딩(embedding)은 에이전트의 지식이나
협조
없이 에이전트의 진행을 중단(비활성화)하거나
재개(활성화)할 수 있습니다. 이럴 경우, 임베딩은 클러스터 내 일부 에이전트만 활성 상태로 두고 나머지 에이전트를 무기한 비활성화된 상태로 남겨두어서는 안 됩니다.
참고 4
이 제한의 목적은 다른 에이전트가
비활성화되어 있는 동안 어떤 에이전트가
교착 상태에 빠지거나 기아 상태에 빠지는 상황을 방지하기 위함입니다. 예를 들어, 문서와 독립적인 수명을 가진 HTML shared worker가, 그런 독립
문서의
dedicated worker와 메모리를 공유할 수 있도록 허용한다면, 그리고 문서와 그 dedicated worker가 dedicated worker가 락을
보유한
상태에서 비활성화된다면(예: 문서가 윈도우의 history에 푸시됨), shared worker가 그 락을 얻으려 하면 dedicated worker가 다시
활성화될
때까지(혹은 영원히) 대기하게 됩니다. 그 동안 다른 윈도우의 워커들이 shared worker에 접근하려 하면 기아 상태가 됩니다.
이 제한의 의미는 임베딩 내 같은 suspend/wake 집합에 속하지 않은 에이전트끼리는 메모리 공유가 불가능하다는 점입니다.
임베딩은 클러스터 내 다른 에이전트의 사전
지식이나
협조 없이 에이전트를 종료시킬 수 있습니다.
만약
에이전트가 자기 자신이나 클러스터 내 다른
에이전트의 프로그래밍적 동작이 아니라 클러스터
외부의
힘에 의해 종료된다면, 임베딩은 두 가지 전략 중 하나를 선택해야 합니다: 클러스터 내 모든 에이전트를 종료시키거나, 클러스터 내 남은 구성원이 종료 사실을 감지할 수 있도록 신뢰할 수 있는 API를
제공하고, 종료 데이터에는 종료된 에이전트를
식별할
수 있는 충분한 정보를 포함해야 합니다.
참고 5
이런 종료의 예시로는: 별도 프로세스에서 실행되는 에이전트를 운영 체제나 사용자가 종료시키는 경우, 임베딩 자체가 같은 프로세스 내에서
실행되는
에이전트를 종료시키는
경우(에이전트별
자원 관리로 에이전트가
runaway임이 감지됨) 등이 있습니다.
아래 명세 값과 그로부터 추이적으로 도달 가능한 값들은 정확히 하나의 에이전트 클러스터에 속합니다.
에이전트 클러스터는 명세 메커니즘일 뿐이며, ECMAScript 구현의 어떤 실제 산출물과 반드시 대응하지는 않습니다.
9.8 전진 진행(Forward Progress)
에이전트가 전진
진행(forward
progress)한다는 것은 이 명세에 따라 평가 단계를 수행하는 것입니다.
에이전트는 실행 중인
실행
컨텍스트가 동기적으로, 그리고 무기한 외부 이벤트를 기다릴 때 블록(blocked) 상태가 됩니다. 이 의미에서
블록될 수
있는 것은 에이전트의 에이전트 레코드의 [[CanBlock]] 필드가 true인 경우뿐입니다.
비차단(unblocked)에이전트는 블록되지 않은 에이전트입니다.
한 에이전트가 명시적으로 블로킹을
제공하는
API를 통해서만 다른 에이전트를 블록
상태로
만들 수 있다.
참고
이와 메모리
모델의 라이브니스 보장은 모든 seq-cst 쓰기가 결국 모든
에이전트에서 관찰 가능해짐을
보장합니다.
9.9 WeakRef 및 FinalizationRegistry 대상의 처리 모델
9.9.1 목표
이 명세는 어떤 객체나 심볼도 가비지 컬렉션된다는 보장을 하지 않습니다. 라이브(live)하지 않은 객체나 심볼은 오랜 시간이 지난 뒤에 해제될 수도 있고,
전혀
해제되지 않을 수도 있습니다. 이 때문에, 이 명세는 가비지 컬렉션에 의해 트리거되는 동작을 설명할 때 "may"라는 용어를 사용합니다.
WeakRef.prototype.deref가 호출될 때, (만약 undefined가 반환되지
않는다면) 참조
대상은 살아 있게 유지되며, 이후의 동기적 접근도 동일한 값을 반환합니다. 이 목록은 ClearKeptObjects 추상
연산을
사용해 동기 작업이 완료될 때 재설정됩니다.
일부 ECMAScript 구현은 백그라운드에서, 또는 ECMAScript가 유휴 상태일 때 동작하는 가비지 컬렉터를 포함합니다. 호스트
환경이
CleanupFinalizationRegistry의
스케줄을 제어하도록 하면, finalizer 작업을 실행하기 위해 ECMAScript 실행을 재개할 수 있으므로, 보유 중인 값을 해제하고 전체 메모리 사용량을 줄일
수
있습니다.
9.9.2 라이브니스(Liveness)
어떤 객체/심볼 집합 S에 대해 S에 대한 가상 WeakRef-무시(hypothetical
WeakRef-oblivious) 실행이란, S의 원소를 참조 대상으로 하는 WeakRefDeref의 결과가 항상
undefined를 반환하는 실행입니다.
참고 1
WeakRef-oblivious와 liveness는 두 가지 개념을 포착합니다. 첫째, WeakRef 자체는 참조 대상을 살아
있게 만들지 않습니다. 둘째, 라이브니스의 순환(cycles)은 값이 live임을 의미하지 않습니다. 예를 들어, v의 라이브니스 판정이
WeakRef 참조 대상 r의
라이브니스
판정에 의존할 때, r의 라이브니스는 v의 라이브니스를 전제할 수 없습니다(순환 논증 불가).
참고 2
WeakRef-obliviousness는 순환을 고려하기 위해 개별 값이 아닌 객체/심볼의 집합에 대해 정의됩니다. 만약 개별 값에 대해 정의한다면, 순환
내의
WeakRef 참조 대상은 그 정체성이 오직 순환 내 다른
WeakRef 참조 대상을 통해서만 관찰될지라도 live로 간주될 것입니다.
참고 3
구어적으로, 어떤 객체나 심볼이 포함된 모든 집합이 live라면, 그 객체나 심볼이 live라고 말합니다.
실행 중 아무 시점에서, 객체/심볼 집합 S가 다음 조건 중 하나를 만족하면 live라고 간주합니다:
구현체는 non-live 객체/심볼의 최대 집합에 대해 반드시 WeakRef를 비울 필요는 없습니다.
구현체가 live가 아닌 S 집합에 대해 WeakRef를 비우기로 선택했다면, 이 정의는
S의 모든 값에 대해 동시에 WeakRef를 비워야
함을 요구합니다. 즉, 구현체가
v를 가리키는 WeakRef만 비우고, 나머지 WeakRef를 그대로 두어
v의 값을
관찰할 수 있다면, 이는 준수(conformant)하지 않습니다.
CanBeHeldWeakly 추상 연산은 v (ECMAScript 언어 값)를 인자로
받아
불리언을 반환합니다. v가 약 참조로 사용하기에 적합할 때에만 true를 반환합니다. 약 참조로 사용하기에 적합한 값만
WeakMap의 키, WeakSet의 요소, WeakRef의 대상, 또는 FinalizationRegistry의 대상 중
하나가
될 수 있습니다. 호출 시 다음 단계를 수행합니다:
언어 정체성(language
identity)이 없는 언어 값은 사전 참조 없이 나타날 수 있으므로 약 참조로 사용하기에 부적합합니다.
Symbol.for로 생성된 Symbol 값은 다른 Symbol 값과 달리
언어
정체성이 없으므로 약 참조로 사용하기에 부적합합니다. well-known 심볼은 거의 수집되지 않지만, 그 수가
제한적이므로 다양한 구현 방식으로 관리 가능해 약 참조로 사용에 적합하다고 봅니다. 그러나 live WeakMap에 well-known 심볼에
연관된
값이 있다면, 해당 값은 거의 수집되지 않으며 구현체에 따라 메모리 리소스가 "누수"될 수 있습니다.
10 일반 객체와 익조틱 객체의 동작
10.1 일반 객체 내부 메서드와 내부 슬롯
모든 일반 객체는
[[Prototype]]이라는 내부 슬롯을 갖습니다.
이 내부 슬롯의 값은 null 또는 객체이며, 상속을 구현하는 데 사용됩니다. 만약 속성 P가 일반 객체O에
존재하지 않고, [[Prototype]] 객체에 존재한다면, P가 [[Prototype]] 객체의 데이터 프로퍼티를 참조하는 경우, O는 get 접근에 대해 상속하여
P가 마치 O의 프로퍼티인 것처럼 동작합니다. P가 [[Prototype]]
객체의
쓰기 가능한 데이터
프로퍼티를 참조하면, O에서 P에 set 접근 시 O에
P라는
새로운 데이터
프로퍼티가
생성됩니다. P가 [[Prototype]] 객체의 쓰기 불가능한 데이터 프로퍼티를 참조하면,
O에서 P에 set 접근이 실패합니다. P가 [[Prototype]] 객체의
접근자 프로퍼티를
참조하면, 접근자는 O에 대해 get/set 모두 상속됩니다.
모든 일반 객체는
불리언
값의 [[Extensible]] 내부 슬롯을 가지며, 이는 6.1.7.3에 명시된 확장성 관련
내부
메서드 불변식을 충족시키는 데 사용됩니다. 즉, 객체의 [[Extensible]] 내부 슬롯 값이
false로 설정되면, 더 이상 객체에 프로퍼티를 추가하거나, [[Prototype]] 내부 슬롯을
수정하거나, [[Extensible]] 값을 다시 true로 변경할 수 없습니다.
각 일반 객체 내부
메서드는 같은 이름의 추상 연산에 위임합니다. 만약 그러한 추상 연산이 다른 내부 메서드에 의존하면, 직접 추상 연산을 호출하는 대신 O에서 내부 메서드를
호출합니다.
이러한 의미론은 익조틱
객체에
대해 일반 객체
내부
메서드를 적용할 때, 오버라이드된 내부 메서드가 호출되도록 보장합니다.
10.1.1[[GetPrototypeOf]] ( )
일반 객체O의 [[GetPrototypeOf]] 내부 메서드는 인자를 받지 않으며, 객체 또는
null을 포함하는 정상 완료를
반환합니다.
호출 시 다음 단계를 수행합니다:
10.1.6.3 ValidateAndApplyPropertyDescriptor ( O,
P, extensible, Desc, current )
추상 연산 ValidateAndApplyPropertyDescriptor는 O (객체 또는 undefined),
P (프로퍼티
키), extensible (불리언), Desc (프로퍼티 디스크립터),
current (프로퍼티
디스크립터 또는 undefined)를 인자로 받고, 불리언을 반환한다.
Desc가 지정된 extensibility와 현재 프로퍼티 current를 가진 객체의 프로퍼티로써 적용
가능하여
불변성을 유지할 수
있을 때,
그리고 그 경우에만 true를 반환한다.
그런 적용이 가능하고 O가 undefined가 아니면 프로퍼티 이름 P에 대해 실제로
적용한다(필요하다면 생성). 호출 시 다음 단계를 수행한다:
Desc에 [[Configurable]] 필드가 있으면
configurable을 Desc.[[Configurable]]로, 없으면
current.[[Configurable]]로 둔다.
Desc에 [[Enumerable]] 필드가 있으면
enumerable을 Desc.[[Enumerable]]로, 없으면 current.[[Enumerable]]로 둔다.
객체 O의 이름이 P인 프로퍼티를 접근자 프로퍼티로 교체한다. [[Configurable]] 및 [[Enumerable]] 속성은 각각
configurable과
enumerable로, [[Get]] 및 [[Set]] 속성은 Desc에 해당 필드가 있으면 그 값,
없으면
기본값으로
설정한다.
Desc에 [[Configurable]] 필드가 있으면
configurable을 Desc.[[Configurable]]로, 없으면
current.[[Configurable]]로 둔다.
Desc에 [[Enumerable]] 필드가 있으면
enumerable을 Desc.[[Enumerable]]로, 없으면 current.[[Enumerable]]로 둔다.
객체 O의 이름이 P인 프로퍼티를 데이터 프로퍼티로 교체한다. [[Configurable]] 및 [[Enumerable]] 속성은 각각
configurable과
enumerable로, [[Value]] 및 [[Writable]] 속성은 Desc에 해당 필드가 있으면
그
값, 없으면 기본값으로
설정한다.
그 외의 경우,
Desc의 각 필드에 대해, 객체 O의 이름이 P인 프로퍼티의
해당
속성을 그 값으로 설정한다.
10.1.12 OrdinaryObjectCreate ( proto [ ,
additionalInternalSlotsList ] )
OrdinaryObjectCreate 추상 연산은 proto (객체 또는 null), 선택적
additionalInternalSlotsList (내부 슬롯 이름의
리스트)를
인자로 받아 객체를 반환한다. 이는 새로운 일반 객체의 런타임 생성을 명세하는 데 사용된다.
additionalInternalSlotsList에는 [[Prototype]], [[Extensible]] 외에 객체의 일부로 정의되어야 하는 추가 내부 슬롯의 이름이 포함된다.
additionalInternalSlotsList가 생략되면, 새로운 빈 List가 사용된다. 호출 시 다음 단계를
수행한다:
internalSlotsList를 « [[Prototype]], [[Extensible]] »로 둔다.
additionalInternalSlotsList가 있으면, internalSlotsList를 리스트
연결 결과(internalSlotsList +
additionalInternalSlotsList)로 설정한다.
OrdinaryObjectCreate는 MakeBasicObject만 호출하는 것처럼 보이지만, 이 연산을
사용하는 것은 일반
객체(exotic이 아님)를 생성하려는 의도를 명확히 전달합니다. 따라서, 이 명세 내에서
OrdinaryObjectCreate를 호출한 후 그 객체의 내부 메서드를 변경해서 exotic으로 만드는 알고리즘은 없습니다. exotic
객체를
생성하는 연산은 직접 MakeBasicObject를 호출합니다.
OrdinaryCreateFromConstructor 추상 연산은 constructor (함수 객체),
intrinsicDefaultProto (문자열), 선택적 internalSlotsList (내부 슬롯 이름의 리스트)를 인자로 받아,
객체를
포함하는 정상 완료 또는 throw completion을 반환한다.
이는
[[Prototype]] 값을 constructor의 "prototype" 프로퍼티에서
가져오고,
없으면 intrinsicDefaultProto로 지정된 intrinsic을 사용하는 일반 객체를 생성한다.
internalSlotsList에는 객체의 일부로 정의해야 하는 추가 내부 슬롯의 이름이 들어있다. internalSlotsList가
생략되면, 새로운 빈 List가 사용된다. 호출 시 다음 단계를
수행한다:
Assert:
intrinsicDefaultProto는 명세에서 정의한 intrinsic 객체의 이름이다. 해당 객체는 객체의 [[Prototype]] 값으로 사용하도록 지정된 intrinsic이어야 한다.
GetPrototypeFromConstructor 추상 연산은 constructor (함수 객체),
intrinsicDefaultProto (문자열)를 인자로 받아, 객체를 포함하는 정상 완료 또는 throw completion을 반환한다.
이는
특정 constructor에
대해 객체를 만들 때 사용할 [[Prototype]] 값을 결정한다. 값은 constructor의
"prototype"
프로퍼티에서 가져오고, 없으면 intrinsicDefaultProto로 지정된 intrinsic이 사용된다. 호출 시 다음 단계를 수행한다:
Assert:
intrinsicDefaultProto는 명세에서 정의한 intrinsic 객체의 이름이다. 해당 객체는 객체의 [[Prototype]] 값으로 사용하도록 지정된 intrinsic이어야 한다.
proto를 realm의 intrinsicDefaultProto 이름의
intrinsic
객체로 설정한다.
proto를 반환한다.
참고
constructor가 [[Prototype]] 값을 제공하지 않으면, 사용되는 기본값은
realm에서 가져오며,
실행 중인 실행 컨텍스트에서 가져오지 않는다.
10.1.15 RequireInternalSlot ( O, internalSlot
)
RequireInternalSlot 추상 연산은 O (ECMAScript 언어 값),
internalSlot (내부 슬롯 이름)을 인자로 받아, unused를 포함하는 정상 완료 또는 throw completion을 반환한다.
O가 객체가 아니거나 해당 내부 슬롯이 없으면 예외를 던진다. 호출 시 다음 단계를 수행한다:
ECMAScript 함수
객체는 렉시컬 환경을 닫아 매개변수를 가진 ECMAScript 코드를 캡슐화하고, 그 코드의 동적 평가를 지원합니다. ECMAScript
함수 객체는
일반 객체이며,
다른
일반 객체와
동일한 내부
슬롯과 내부 메서드를 가집니다. ECMAScript 함수 객체의 코드는 엄격 모드 코드 (11.2.2) 또는
비엄격 코드일 수
있습니다. ECMAScript 함수
객체 중 그 코드가 엄격 모드 코드인 것을 엄격 함수라 합니다. 코드가 엄격 모드
코드가
아닌 것은 비엄격 함수라 합니다.
[[Extensible]]와 [[Prototype]] 외에, ECMAScript
함수 객체는
표 30에 나열된 내부 슬롯도
가집니다.
함수의 형식 매개변수 및 코드 본문 내에서 this 참조가 해석되는 방식을 정의합니다.
lexical은 this가 렉시컬 상위 함수의
this 값을 참조함을 의미합니다. strict는 함수 호출 시
제공된
this 값을 그대로 사용함을 의미합니다. global은
this 값이 undefined 또는
null이면
글로벌
객체로 해석하고, 그 외의 값은 ToObject를 거쳐 객체로
변환합니다.
OrdinaryFunctionCreate 추상 연산은 functionPrototype (객체), sourceText (유니코드 코드
포인트
시퀀스), ParameterList (파스 노드), Body (파스
노드), thisMode (lexical-this 또는
non-lexical-this), env (환경
레코드), privateEnv
(PrivateEnvironment 레코드 또는
null)를 인자로 받아, ECMAScript 함수 객체를 반환한다. 이 연산은 기본 [[Call]] 내부 메서드를 가지며 [[Construct]] 내부 메서드는
없는(단,
MakeConstructor와 같은 연산으로 추가될 수 있음) 새 함수를 런타임에
생성하는 데 사용된다. sourceText는 생성할 함수의 문법 정의 소스 텍스트이다. 호출 시 다음 단계를 수행한다:
추상 연산 MakeConstructor는 F (ECMAScript 함수 객체 또는 내장 함수 객체), 선택적
writablePrototype (불리언), prototype (객체)을 인자로 받아
unused를 반환한다. 이 연산은 F를 생성자로 변환한다. 호출 시 다음 단계를 수행한다:
ECMAScript 함수의 평가를 위해 실행 컨텍스트가 설정되면 새로운 Function Environment
Record가 생성되고, 각 형식 매개변수에 대한 바인딩이 해당 Environment Record에 인스턴스화된다. 함수
본문의 각 선언도 인스턴스화된다. 함수의 형식 매개변수에 기본값 이니셜라이저가 없으면 본문 선언은 매개변수와 같은 Environment Record에서 인스턴스화된다. 기본값
매개변수 이니셜라이저가 있으면, 본문 선언을 위한 두 번째 Environment Record가
생성된다. 형식 매개변수와 함수는 FunctionDeclarationInstantiation의 일부로 초기화된다. 그 외의 모든 바인딩은 함수 본문 평가 중에
초기화된다.
내장 함수 객체는
10.3.1에
정의된 [[Call]] 내부 메서드를 반드시 가져야 합니다.
내장 함수 객체는
“생성자”로 기술되어 있거나,
이 명세의 어떤 알고리즘이 명시적으로 [[Construct]] 내부 메서드를 설정한 경우에만 [[Construct]] 내부 메서드를 가집니다. 이러한 [[Construct]] 내부
메서드는 반드시 10.3.2에
정의된 내용을 따라야 합니다.
result를 Completion
Record로, F를 이 명세에 정의된 대로 평가한
결과로 둔다. thisArgument가 uninitialized이면
this 값은 미초기화 상태이고, 아니면 thisArgument가
this 값을 제공한다. argumentsList는 명명된 파라미터를 제공하며,
newTarget은 NewTarget 값을 제공한다.
참고: F가 이 문서에서 정의된 경우, “the specification of F”는 알고리즘 단계 또는 그 외
수단으로 명세된 동작이다.
CreateBuiltinFunction 추상 연산은 behaviour (Abstract Closure, 알고리즘 단계 집합,
또는 명세 내에서 함수 동작을 정의한 기타 수단), length (0 이상의 정수 또는 +∞), name (프로퍼티 키 또는
Private
Name), additionalInternalSlotsList (내부 슬롯 이름 리스트), 그리고 선택적
realm (Realm
Record), prototype (객체 또는 null),
prefix (문자열)을 인자로 받아 내장 함수 객체를 반환한다.
additionalInternalSlotsList에는 객체의 일부로 정의되어야 하는 추가 내부 슬롯 이름이 포함된다. 이 연산은 내장 함수 객체를
생성한다. 호출 시 다음 단계를 수행한다:
이 명세에 정의된 모든 내장 함수는 CreateBuiltinFunction 추상 연산을 호출하여 생성된다.
10.4 내장 익조틱(Exotic) 객체의 내부 메서드와 슬롯
이 명세는 여러 종류의 내장 익조틱
객체를 정의합니다. 이러한 객체들은 몇몇 특정 상황을 제외하면 일반적으로 일반 객체와 비슷하게 동작합니다. 아래의 익조틱 객체들은 별도로 명시된
경우를 제외하고는 일반
객체의 내부 메서드를 사용합니다:
10.4.1 바운드 함수 익조틱 객체
바운드 함수 익조틱 객체는 또 다른 함수 객체를 감싸는
익조틱
객체입니다. 바운드 함수 익조틱 객체는 호출 가능하며([[Call]] 내부 메서드를 가지고 있을 수 있고, [[Construct]] 내부
메서드도 가질 수 있습니다), 이를 호출하면 일반적으로 감싸고 있는 함수가 호출됩니다.
객체가 [[Call]] 및 (해당되는 경우) [[Construct]] 내부 메서드가
아래 구현을 따르고, 그 외의 필수 내부 메서드는 10.1의 정의를
따른다면, 그 객체는 바운드 함수 익조틱 객체입니다. 이러한 메서드는 BoundFunctionCreate에서
설치됩니다.
바운드 함수 익조틱 객체는 표 30에 나열된
ECMAScript 함수
객체의 내부 슬롯을 가지지 않습니다. 대신, [[Prototype]] 및 [[Extensible]]와 더불어 표 31에 나열된
내부 슬롯을 가집니다.
배열(Array)은 익조틱
객체로, 배열 인덱스프로퍼티 키에 대해 특별한 처리를 합니다(자세한 내용은
6.1.7
참고). 프로퍼티
이름이 배열 인덱스인 프로퍼티는 요소(element)라고도 부릅니다. 모든 배열은 항상
0 이상의 정수(Number) 값을 가지며, 그 수학적
값이 232 미만인, 변경 불가능(non-configurable)한
"length" 프로퍼티를 가집니다. "length" 프로퍼티의 값은 그 이름이 배열 인덱스인 모든 자신의 프로퍼티
이름보다 숫자적으로 큽니다. 배열의 자신의 프로퍼티가 생성되거나 변경될 때마다 이 불변식(invariant)을 유지하기 위해 다른 프로퍼티들도 필요에 따라 조정됩니다.
구체적으로, 이름이 배열
인덱스인 자신의 프로퍼티가 추가되면, 필요하다면 "length" 프로퍼티의 값을 해당
배열 인덱스의 수치값 +
1로 변경합니다. 그리고 "length"의 값이 변경될 때마다, 그 값 이상인 모든 배열 인덱스 이름을 가진 자신의 프로퍼티를 삭제합니다. 이 제약은
배열의 자신의 프로퍼티에만 적용되며, "length"나 배열 인덱스 프로퍼티가 프로토타입에서 상속된 경우에는 영향을 미치지
않습니다.
객체의 [[DefineOwnProperty]] 내부 메서드가 아래 구현을 따르고, 그 외의 필수 내부 메서드가 10.1의 정의를
따른다면, 그 객체는 배열 익조틱
객체(또는 간단히 배열)입니다. 이러한 메서드는 ArrayCreate에서 설치됩니다.
ArrayCreate 추상 연산은 length (0 이상의 정수), 선택적 proto (객체)를 인자로 받아, 배열 익조틱
객체를 포함하는 정상 완료
또는 throw completion을
반환합니다. 이는 새로운 배열 생성 시 사용됩니다. 호출 시 다음 단계를 수행합니다:
ArraySpeciesCreate 추상 연산은 originalArray (객체), length (0 이상의 정수)를 인자로 받아, 객체를 포함하는
정상 완료 또는 throw completion을
반환합니다. 이는 originalArray에서 파생된 생성자 함수를 사용해 새로운 배열 또는 유사 객체를 생성할 때 사용됩니다. 여기서
생성자 함수가
반드시 Array를 반환할 필요는 없습니다. 호출 시 다음 단계를 수행합니다:
originalArray가 realm이 실행 중인 실행 컨텍스트의 realm와 다를 때, 표준 내장
Array 생성자로 생성된 경우에는 실행 중인 실행 컨텍스트의 realm에서 새로운 배열이
생성됩니다. 이는 ArraySpeciesCreate를 사용하는 Array.prototype 메서드가 역사적으로 웹 브라우저에서
이런 동작을 보였던 것과의 호환성을 유지하기 위한 것입니다.
3 및 4 단계에서
Desc.[[Value]]가 객체인 경우 valueOf 메서드가
두 번 호출됩니다. 이는 2판(Edition 2) 명세에서 이 효과를 명시한 이후로 유지되고 있는 레거시 동작입니다.
10.4.3 문자열 익조틱 객체
String 객체는 문자열 값을 캡슐화하고, 해당 문자열 값의 각 코드 유닛 요소에 대응하는 가상 정수 인덱스데이터 프로퍼티를
노출하는 익조틱
객체입니다. 문자열 익조틱 객체는 항상 캡슐화된 문자열 값의 길이를 값으로 갖는
"length"라는 이름의 데이터 프로퍼티를 가집니다. 코드 유닛 데이터 프로퍼티와
"length" 프로퍼티 모두 쓰기 불가 및 재정의 불가(non-configurable)입니다.
객체의 [[GetOwnProperty]], [[DefineOwnProperty]],
[[OwnPropertyKeys]] 내부 메서드가 아래 구현을 따르고, 그 외의 필수 내부 메서드는 10.1의 정의를
따른다면, 그 객체는 문자열
익조틱 객체(혹은 간단히 String 객체)입니다. 이 메서드들은 StringCreate에서 설치됩니다.
문자열 익조틱
객체는 일반 객체와 동일한 내부 슬롯을 가지며, 추가로 [[StringData]] 내부 슬롯을 가집니다.
대부분의 ECMAScript 함수는 arguments 객체를 코드에서 사용할 수 있도록 제공합니다. 함수 정의의 특성에 따라, arguments 객체는 일반 객체이거나
arguments 익조틱 객체입니다. arguments
익조틱 객체는 익조틱 객체로, 배열 인덱스 프로퍼티가 관련 ECMAScript 함수의 호출 시 형식
매개변수 바인딩과 매핑됩니다.
객체의 내부 메서드가 아래 구현을 따르고, 여기 명시되지 않은 메서드는 10.1의 정의를
따른다면, 그 객체는 arguments 익조틱 객체입니다. 이러한 메서드는 CreateMappedArgumentsObject에서
설치됩니다.
Arguments 익조틱 객체는 일반 객체와 동일한
내부 슬롯을 가지고 있습니다. 또한 [[ParameterMap]] 내부 슬롯을 가집니다. 일반 arguments 객체도 [[ParameterMap]] 내부 슬롯을 가지지만, 그 값은 항상 undefined입니다.
일반 arguments 객체에서 [[ParameterMap]] 내부 슬롯은
Object.prototype.toString (20.1.3.6)에서 해당 객체임을
식별하는 데만 사용됩니다.
참고 2
arguments 익조틱 객체의 정수 인덱스데이터
프로퍼티 중 이름이 해당 함수 객체의 형식 매개변수 개수보다 작은 것은 처음에 함수
실행 컨텍스트의 인수 바인딩과 값을 공유합니다. 즉,
프로퍼티를 변경하면 인수 바인딩의 값도 바뀌고 그 반대도 마찬가지입니다. 이 대응은 해당 프로퍼티를 삭제 후 재정의하거나 접근자 프로퍼티로 바꾸면 끊어집니다.
arguments 객체가 일반 객체라면, 프로퍼티의 값은 함수에 전달된 인수의 복사본일 뿐이며,
프로퍼티 값과 형식 매개변수 값 사이에 동적 연결은 없습니다.
참고 3
ParameterMap 객체와 그 프로퍼티 값은 arguments 객체와 인수 바인딩의 대응을 명세하기 위한 장치로 사용됩니다. ParameterMap 객체와
그 프로퍼티 값 객체는 ECMAScript 코드에서 직접 관찰할 수 없습니다. 명세된 의미론을 구현하기 위해, ECMAScript 구현체는 실제로 이러한
객체를 생성하거나 사용할 필요가 없습니다.
참고 4
일반 arguments 객체는 접근 시 TypeError 예외를 던지는 "callee"라는
이름의 변경 불가 접근자 프로퍼티를 정의합니다. arguments 익조틱 객체는
"callee" 프로퍼티에 대해 좀 더 구체적인 의미를 가지며, 이는 일부 비엄격
함수에 대해서만 생성됩니다. 일반 variant에서 이 프로퍼티를 정의하는 것은, ECMAScript 구현체가 이와
다른 방법으로 프로퍼티를 정의하지 않도록 보장하기 위함입니다.
참고 5
ECMAScript의 arguments 익조틱 객체 구현체는 역사적으로
"caller"라는 접근자 프로퍼티를 포함하는 경우가 있었습니다. ECMAScript 2017 이전에는 이 명세서에 일반
arguments 객체에 대해 예외를 던지는 "caller" 프로퍼티 정의가 포함되어 있었습니다. 현재는 구현체가 더 이상
이 확장을 포함하지 않으므로, ECMAScript 2017에서 이 요구사항을 삭제하였습니다.
TypedArray는
익조틱 객체로,
프로퍼티 키 중
정규 숫자 문자열인 것들을 특별하게 처리하며, 그 중 경계
내의 정수
인덱스에 해당하는 값은 균일 타입의 요소 인덱싱에 사용하고, 나머지는 프로토타입 체인 탐색 없이 존재하지 않는 것으로 강제하는
불변식을 유지합니다.
TypedArray는
일반
객체와 동일한 내부 슬롯을 가지며, 추가로 [[ViewedArrayBuffer]],
[[TypedArrayName]], [[ContentType]], [[ByteLength]], [[ByteOffset]], [[ArrayLength]] 내부 슬롯을 가집니다.
객체의 [[PreventExtensions]], [[GetOwnProperty]],
[[HasProperty]], [[DefineOwnProperty]], [[Get]], [[Set]], [[Delete]], [[OwnPropertyKeys]] 내부 메서드가 이 절의
정의를 따르고, 그 외의 필수 내부 메서드는 10.1의 정의를
따른다면, 그 객체는 TypedArray입니다. 이러한 메서드는
TypedArrayCreate로 설치됩니다.
10.4.5.1[[PreventExtensions]] ( )
TypedArrayO의 [[PreventExtensions]] 내부 메서드는 인자를 받지 않으며, 불리언을 포함하는
정상 완료를 반환합니다. 호출 시
다음 단계를 수행합니다:
참고: 6.1.7.3의
확장성 관련 불변식에 따라, O가 프로퍼티를 얻거나(또는 잃고 다시 얻거나) 할 수 있으면(예: 내부 버퍼가 리사이즈될 때 정수
인덱스 프로퍼티), 이 메서드는 true를 반환할 수 없습니다.
TypedArray With
Buffer Witness Record는 레코드(Record) 값으로,
TypedArray와
함께 버퍼의 바이트 길이 캐시를 캡슐화합니다. 이는
확장 가능한
SharedArrayBuffer를 볼 때,
바이트 길이 데이터 블록에 대한 단일 공유 메모리 읽기 이벤트가 보장되도록 돕기 위해 사용됩니다.
TypedArray With Buffer Witness Record에는 표 32에 나열된
필드가 있습니다.
추상 연산 IsTypedArrayOutOfBounds는 taRecord (TypedArray With Buffer Witness
Record)를 인수로 받아 불리언 값을 반환한다. 이 연산은 객체의 수치 프로퍼티가 기본 버퍼의 범위 내에 포함되지 않은
인덱스를 참조하는지 검사한다. 호출 시 다음 단계를 수행한다:
O를 taRecord.[[Object]]로 한다.
bufferByteLength를 taRecord.[[CachedBufferByteLength]]로 한다.
Assert:
IsDetachedBuffer(O.[[ViewedArrayBuffer]])는 true이고 오직
bufferByteLength가 detached일 때만 그렇다.
SetValueInBuffer(O.[[ViewedArrayBuffer]], byteIndexInBuffer,
elementType, numValue, true,
unordered)를 수행한다.
unused를 반환한다.
참고
이 연산은 항상 성공하는 것처럼 보이지만, TypedArray의 끝을 넘어 쓰기를 시도하거나
분리(detached)된 ArrayBuffer를 사용하는 TypedArray에 쓰기를 시도하면 아무 효과가 없다.
10.4.5.19 IsArrayBufferViewOutOfBounds ( O )
추상 연산 IsArrayBufferViewOutOfBounds는 O (TypedArray 또는 DataView)를 인수로 받아 불리언
값을 반환한다. 이 연산은 TypedArray의 수치 프로퍼티 또는 DataView 객체의 메서드가 기본 데이터
블록의 범위 내에 포함되지 않은 인덱스를 참조할 수 있는지 검사한다. 이 추상 연산은 상위 명세에서 편의를 위해 존재한다. 호출 시 다음 단계를 수행한다:
객체의 [[GetPrototypeOf]], [[SetPrototypeOf]],
[[IsExtensible]], [[PreventExtensions]], [[GetOwnProperty]], [[DefineOwnProperty]], [[HasProperty]], [[Get]], [[Set]], [[Delete]], [[OwnPropertyKeys]] 내부 메서드가 이 절의 정의를 사용하고,
나머지 필수 내부 메서드는 10.1의 정의를
사용하는 경우, 그 객체는
모듈 네임스페이스 이그조틱 객체입니다.
이러한 메서드는 ModuleNamespaceCreate에 의해 설치됩니다.
ResolveExport는 부작용이 없습니다. 이 연산이 특정 exportName, resolveSet 쌍을
인수로 받아 호출될 때마다 항상 같은 결과를 반환해야 합니다. 구현체는 각 [[Exports]]에 대해
ResolveExport 결과를 미리 계산하거나 캐시할 수 있습니다.
프록시 객체는 익조틱
객체로, 필수 내부 메서드가 부분적으로 ECMAScript 코드로 구현되어 있습니다. 모든 프록시 객체는 [[ProxyHandler]]라는 내부 슬롯을 가집니다. [[ProxyHandler]]의
값은
프록시의 핸들러 객체라 불리는 객체이거나 null입니다. 핸들러 객체의 메서드들(표
34 참고)은 하나 이상의 프록시 객체 내부 메서드의 구현을 보강하는 데 사용될 수 있습니다. 모든 프록시 객체는 또한 [[ProxyTarget]]이라는 내부 슬롯을 가지며, 그 값은 객체이거나 null입니다. 이 객체를
프록시의 타겟 객체라고 합니다.
객체가 필수 내부 메서드([[Call]]
및 [[Construct]]를 포함, 해당되는 경우) 구현에 이 절의 정의를 사용하는 경우, 해당 객체를 프록시 익조틱 객체라고 합니다.
이러한 내부 메서드는 ProxyCreate에서 설치됩니다.
표 34: 프록시 핸들러 메서드
내부 메서드
핸들러 메서드
[[GetPrototypeOf]]
getPrototypeOf
[[SetPrototypeOf]]
setPrototypeOf
[[IsExtensible]]
isExtensible
[[PreventExtensions]]
preventExtensions
[[GetOwnProperty]]
getOwnPropertyDescriptor
[[DefineOwnProperty]]
defineProperty
[[HasProperty]]
has
[[Get]]
get
[[Set]]
set
[[Delete]]
deleteProperty
[[OwnPropertyKeys]]
ownKeys
[[Call]]
apply
[[Construct]]
construct
핸들러 메서드가 프록시 객체 내부 메서드의 구현을 제공하기 위해 호출될 때, 핸들러 메서드에는 프록시의 타겟 객체가 인자로 전달됩니다. 프록시의 핸들러 객체는 모든 필수 내부
메서드에 해당하는 메서드를 반드시 가질 필요는 없습니다. 프록시에 대해 내부 메서드를 호출할 때 핸들러 객체에 해당 트랩 메서드가 없으면, 프록시의 타겟 객체의 해당 내부 메서드가
호출됩니다.
프록시 객체의 [[ProxyHandler]] 및 [[ProxyTarget]] 내부 슬롯은
객체가 생성될 때 항상 초기화되며 일반적으로 수정할 수 없습니다. 일부 프록시 객체는 이후에 해제(revoke)될 수 있도록 생성됩니다. 프록시가 해제되면 해당
프록시의 [[ProxyHandler]] 및 [[ProxyTarget]] 내부 슬롯이
null로 설정되어, 이후 해당 프록시 객체의 내부 메서드 호출 시 TypeError 예외가 발생하게 됩니다.
프록시 객체는 내부 메서드의 구현을 임의의 ECMAScript 코드로 제공할 수 있으므로, 핸들러 메서드가 6.1.7.3에 정의된
불변 조건(invariant)을 위반하는 프록시 객체를 정의하는 것도 가능합니다.
6.1.7.3에 정의된 일부 내부
메서드 불변 조건은 본질적인 무결성 불변 조건입니다. 이러한 불변 조건은 본 절에 명시된 프록시 객체 내부 메서드에 의해 명시적으로 강제됩니다. ECMAScript 구현체는 모든
가능한 불변 조건 위반에도 견고해야 합니다.
프록시
익조틱 객체는 [[ProxyTarget]] 내부 슬롯의 초기 값이
[[Construct]] 내부 메서드를 가진 객체인 경우에만 [[Construct]] 내부 메서드를 가집니다.
참고 2
프록시 객체의 [[Construct]]는 다음 불변 조건을 강제합니다:
[[Construct]]의 결과는 반드시 객체여야 합니다.
10.5.14 ValidateNonRevokedProxy ( proxy )
추상 연산 ValidateNonRevokedProxy는 인자 proxy(프록시 익조틱 객체)를 받고, unused를 포함하는 정상 완료 또는
예외 완료를 반환합니다.
proxy가 해제(revoked)된 경우 TypeError 예외를 발생시킵니다. 호출 시 다음 단계를 수행합니다:
ECMAScript 소스 텍스트는 유니코드 코드 포인트들의 시퀀스이다. U+0000부터 U+10FFFF까지의 모든 유니코드 코드 포인트
값(서러게이트 코드 포인트 포함)은 ECMAScript 문법에서 허용되는 곳에 ECMAScript 소스 텍스트에 나타날 수 있다. ECMAScript 소스 텍스트를 저장하고
교환하는 데 사용되는 실제 인코딩은 이 명세와 관련없다. 외부 소스 텍스트 인코딩과 무관하게, 표준 ECMAScript 구현체는 소스 텍스트를 동등한 SourceCharacter 값들의 시퀀스처럼 처리하며, 각
SourceCharacter는 유니코드 코드 포인트이다.
표준 ECMAScript 구현체는 소스 텍스트의 정규화(normalization)를 수행하거나, 수행하는 것처럼 동작할 필요가 없다.
조합 문자 시퀀스(combining character sequence)의 구성 요소는 사용자가 전체 시퀀스를 하나의 문자로 인식할 수도 있지만, 각각 개별 유니코드 코드 포인트로
취급된다.
참고
문자열 리터럴, 정규 표현식 리터럴, 템플릿 리터럴, 식별자에서는 어떤 유니코드 코드 포인트도 해당 코드 포인트의 숫자 값을 명시적으로 표현하는 유니코드 이스케이프
시퀀스를 사용하여 나타낼 수 있다. 주석 내에서는 이러한 이스케이프 시퀀스가 주석의 일부로 무시된다.
ECMAScript는 유니코드 이스케이프 시퀀스의 동작에서 Java 프로그래밍 언어와 다르다. 예를 들어, Java 프로그램에서 유니코드 이스케이프 시퀀스
\u000A가 한 줄짜리 주석 내에 나타나면, 이는 줄 종결자(유니코드 코드 포인트 U+000A는 LINE FEED (LF))로 해석되어 다음
코드 포인트는 주석의 일부가 아니다. 마찬가지로, Java 프로그램의 문자열 리터럴 내에 \u000A가 나타나면, 이것도 줄 종결자로 해석되어
문자열 리터럴 내에 허용되지 않는다—문자열 리터럴 값에 LINE FEED (LF)를 포함하려면 \n을 사용해야 한다. ECMAScript
프로그램에서는 주석 내에 등장하는 유니코드 이스케이프 시퀀스가 해석되지 않으므로 주석의 종료에 기여할 수 없다. 또한, ECMAScript 프로그램의 문자열 리터럴
내에 나타나는 유니코드 이스케이프 시퀀스는 항상 리터럴 값에 포함되며, 줄 종결자나 문자열 리터럴을 종료시킬 수 있는 코드 포인트로 해석되지 않는다.
11.1.1 정적 의미: UTF16EncodeCodePoint ( cp )
추상 연산 UTF16EncodeCodePoint는 인자 cp(유니코드 코드 포인트)를 받아 문자열을 반환한다. 호출 시 다음 단계를 수행한다:
추상 연산 CodePointAt은 인자 string(문자열), position(음이 아닌 정수)를 받아, Record 타입의 [[CodePoint]](코드 포인트), [[CodeUnitCount]](양의
정수), [[IsUnpairedSurrogate]](불리언) 필드를 가진 결과를 반환한다. string을
6.1.4에 설명된 대로 UTF-16
인코딩 코드 포인트 시퀀스로 해석하고, position 위치의 코드 유닛에서 시작하는 코드 포인트 하나를 읽는다. 호출 시 다음 단계를 수행한다:
추상 연산 StringToCodePoints는 인자 string(문자열)을 받아 코드 포인트들의 List를 반환한다.
string을 6.1.4에 설명된 대로 UTF-16
인코딩 유니코드 텍스트로 해석하여 결과로 유니코드 코드 포인트 시퀀스를 반환한다. 호출 시 다음 단계를 수행한다:
추상 연산 ParseText는 인자 sourceText(문자열 또는 유니코드 코드 포인트 시퀀스),
goalSymbol(ECMAScript 문법의 비종결 기호(nonterminal))을 받아, 파스 노드(Parse
Node) 또는 비어 있지 않은 List의
SyntaxError 객체들을 반환한다. 호출 시 다음 단계를 수행한다:
파싱이 성공하고 조기
에러가 발견되지 않았다면, 파싱으로 얻어진 파스 트리의 루트에서 파스
노드(goalSymbol의 인스턴스)를 반환한다.
그렇지 않으면, 파싱 오류 및/또는 조기 에러를 나타내는 하나 이상의
SyntaxError 객체들의 List를 반환한다. 둘 이상의
파싱 오류 또는 조기
에러가 있는 경우, 오류 객체의 개수와 순서는 구현
정의이지만, 하나 이상은 반드시 포함되어야 한다.
참고 1
특정 위치에 조기
에러가 있고, 이후 위치에 구문 오류가 있는 텍스트를 생각해보자. 파싱 후 조기 에러 탐지
단계를 수행하는 구현체는 구문 오류만 보고하고 조기 에러 탐지를 진행하지 않을 수도 있다. 두 단계를
교차(interleave)하는 구현체는 조기 에러만 보고하고 구문 오류를 찾지 않을 수도 있다. 세 번째 구현체는 두
에러 모두를 보고할 수도 있다. 이 모든 동작은 적합하다.
ECMAScript 구현체는 실행 동작이 호스트
정의 실행 코드 형태로 표현되는 함수 익조틱 객체의 평가를 지원할 수 있다. 함수 객체가
ECMAScript 코드 내에서 정의되었는지, 내장 함수인지는 그러한 함수 객체를 호출하거나, 그에 의해 호출되는 ECMAScript 코드의 관점에서는 관찰할
수 없다.
12 ECMAScript 언어: 렉시컬 문법
ECMAScript Script 또는
Module의 소스 텍스트는 먼저 입력 요소들의 시퀀스로 변환된다. 입력 요소란
토큰, 줄 종결자, 주석, 또는 공백이다. 소스 텍스트는 왼쪽에서 오른쪽으로 스캔되며, 가능한 한 가장 긴 코드 포인트 시퀀스를 다음 입력 요소로 반복적으로 선택한다.
여러 렉시컬 목표를 사용하는 것은 자동 세미콜론 삽입에 영향을 줄 수 있는 렉시컬 모호성이 없도록 보장한다. 예를 들어, 선행하는 나눗셈 또는 나눗셈 할당과 선행하는
RegularExpressionLiteral이 모두 허용되는 구문
문법 컨텍스트는 없다. 이것은 세미콜론 삽입(자세한 내용은 12.10 참고)에 영향을 받지
않는다. 예를 들어 다음과 같은 경우:
a = b
/hi/g.exec(c).map(d);
여기서 LineTerminator 뒤의 첫 번째
공백·주석이 아닌 코드 포인트가 U+002F(SOLIDUS)이고, 구문 컨텍스트가 나눗셈 또는 나눗셈 할당을 허용한다면, 해당 LineTerminator 위치에 세미콜론이 삽입되지
않는다. 즉, 위의 예시는 다음과 동일하게 해석된다:
유니코드 형식 제어 문자(즉, 유니코드 문자 데이터베이스에서 “Cf” 범주에 속하는 문자들, 예: LEFT-TO-RIGHT MARK 또는 RIGHT-TO-LEFT MARK)는 상위
수준의 프로토콜(마크업 언어 등)이 없는 경우에 텍스트 범위의 서식을 제어하는 데 사용되는 제어 코드입니다.
편집과 표시를 용이하게 하기 위해 소스 텍스트에 형식 제어 문자를 허용하는 것이 유용합니다. 모든 형식 제어 문자는 주석, 문자열 리터럴, 템플릿 리터럴, 정규 표현식 리터럴 내에서
사용할 수 있습니다.
U+FEFF(ZERO WIDTH NO-BREAK SPACE)는 주로 텍스트의 시작 부분에서 유니코드임을 표시하고 텍스트의 인코딩과 바이트 순서를 감지할 수 있도록 하는 형식 제어
문자입니다.
이러한 목적을 가진 <ZWNBSP> 문자는 파일을 연결(concatenate)하는 등의 작업 결과로 텍스트의 시작 이후에도 나타날 수 있습니다. ECMAScript 소스
텍스트에서 <ZWNBSP> 코드 포인트는 주석, 문자열 리터럴, 템플릿 리터럴, 정규 표현식 리터럴 외부에서는 공백 문자로
취급됩니다(자세한 내용은 12.2 참고).
12.2 공백(White Space)
공백 코드 포인트는 소스 텍스트의 가독성을 높이고, 토큰(분할 불가능한 렉시컬 단위)들 사이를 구분하는 데 사용되지만, 그 외에는 의미가 없습니다. 공백 코드 포인트는 어떤 두 토큰
사이에도, 입력의 시작이나 끝에도 올 수 있습니다. 공백 코드 포인트는 StringLiteral,
RegularExpressionLiteral, Template, TemplateSubstitutionTail 내에도 등장할 수 있으며, 이
경우에는 리터럴 값의 일부를 이루는 의미 있는 코드 포인트로 간주됩니다. 또한 Comment 내에도 등장할 수 있지만, 다른 종류의 토큰 내에는 등장할 수 없습니다.
공백 코드 포인트와 마찬가지로, 줄 종결자 코드 포인트도 소스 텍스트의 가독성을 높이고, 토큰(분할 불가능한 렉시컬 단위) 사이를 구분하는 데 사용됩니다. 하지만 공백 코드 포인트와
달리, 줄 종결자는 구문 문법의 동작에 일부 영향을 미칩니다. 일반적으로 줄 종결자는 어떤 두 토큰 사이에도 올 수 있지만, 구문 문법에 의해 금지되는 위치도 일부 있습니다. 줄
종결자는 자동 세미콜론 삽입(12.10) 과정에도 영향을 미칩니다. 줄 종결자는
StringLiteral, Template, TemplateSubstitutionTail 토큰 이외의 어떤 토큰 내에도
올 수 없습니다. <LF>와 <CR> 줄 종결자는 StringLiteral 토큰 내에 LineContinuation의 일부로 나타나는 경우를 제외하고는 올 수 없습니다.
표 36에 있는 유니코드 코드 포인트만 줄 종결자로 취급됩니다.
다른 줄 바꿈 또는 줄 나눔 유니코드 코드 포인트는 줄 종결자로 취급되지 않으며, 표 35의 조건을 만족하는 경우에만 공백으로
취급됩니다. <CR><LF> 시퀀스는 줄 종결자로 자주 사용됩니다. 이는 줄 번호를 보고(report)할 때 하나의 SourceCharacter로 간주되어야 합니다.
한 줄 주석에는 LineTerminator 코드 포인트를
제외한 임의의 유니코드 코드 포인트가 올 수 있고, 일반적으로 토큰은 항상 가능한 한 가장 길게 취해지므로, 한 줄 주석은 // 마커에서 그 줄의 끝까지의
모든 코드 포인트로 구성됩니다. 그러나, 줄 끝의 LineTerminator는 한 줄 주석의 일부로 간주되지 않습니다. 이는 렉시컬 문법에서
별도로 인식되며, 구문 문법의 입력 요소 스트림의 일부가 됩니다. 이 점은 매우 중요한데, 한 줄 주석의 존재 여부가 자동 세미콜론 삽입 과정에 영향을 주지 않음을
의미합니다(자세한 내용은 12.10 참고).
IdentifierName과 ReservedWord는 Unicode Standard Annex
#31, Identifier and Pattern Syntax에 명시된 기본 식별자 문법(Default Identifier Syntax)을 약간 수정하여 해석되는 토큰입니다.
ReservedWord는 IdentifierName의 열거된 부분집합입니다. 구문 문법은
Identifier를 IdentifierName이면서 ReservedWord가 아닌 것으로 정의합니다. 유니코드 식별자
문법은 유니코드 표준에 명시된 문자 속성을 기반으로 합니다. 최신 버전의 유니코드 표준에서 지정된 범주의 유니코드 코드 포인트는 모든 호환 ECMAScript 구현체에서 해당
범주로 다뤄져야 합니다. ECMAScript 구현체는 이후 유니코드 표준 버전에 정의된 식별자 코드 포인트도 인식할 수 있습니다.
참고 1
이 표준은 다음의 특정 코드 포인트를 추가로 허용합니다: U+0024(DOLLAR SIGN)와 U+005F(LOW LINE)은 IdentifierName 어디에서든 사용할 수
있습니다.
키워드는 IdentifierName과 일치하지만, 구문적으로 사용되는 토큰입니다. 즉, 구문
생성규칙에서 고정폭(fixed width) 글꼴로 문자 그대로 등장합니다. ECMAScript의 키워드에는 if,
while, async, await 등 여러 가지가 있습니다.
예약어는 식별자로 사용할 수 없는 IdentifierName입니다. 많은 키워드가 예약어이지만, 일부는 아니기도 하며,
일부는 특정 컨텍스트에서만 예약어입니다. if와 while은 예약어입니다. await는 async
함수와 모듈 내에서만 예약어입니다. async는 예약어가 아니며, 변수명이나 statement label로 자유롭게 사용할 수 있습니다.
이 명세는 문법 생성규칙과 조기
에러 규칙의 조합으로 어떤 이름이 유효한 식별자인지, 어떤 이름이 예약어인지 명시합니다. 아래 ReservedWord 목록의 모든 토큰(단,
await와 yield는 제외)은 무조건적으로 예약어입니다. await와
yield의 예외는 13.1에서 파라미터화된 구문 생성규칙을 통해 명시됩니다. 마지막으로, 여러
조기 에러 규칙이 유효한
식별자의 집합을 제한합니다. 자세한 내용은 13.1.1, 14.3.1.1,
14.7.5.1,
15.7.1 참고.
요약하면, 식별자 이름에는 다섯 가지 범주가 있습니다:
항상 식별자로 허용되고 키워드가 아닌 것들(Math, window, toString,
_ 등)
식별자로 절대 허용되지 않는 것들(아래 ReservedWord 목록 중 await와
yield를 제외한 것들)
컨텍스트에 따라 식별자로 허용되는 것들(await와 yield)
엄격
모드 코드에서 컨텍스트에 따라 식별자로 허용되지 않는 것들: let,
static, implements, interface,
package, private, protected, public
항상 식별자로 허용되지만, 특정 구문 생성규칙 내에서 Identifier가 허용되지 않는 위치에서 키워드로도 등장하는
것들(as, async, from, get,
meta, of, set, target)
조건부 키워드 또는 컨텍스트 키워드라는 용어는 마지막 세 범주에 속하는 키워드들을 일컫기도
하며, 이들은 어떤 컨텍스트에서는 식별자로, 어떤 컨텍스트에서는 키워드로 사용될 수 있습니다.
문자열 리터럴은 작은따옴표 또는 큰따옴표로 감싸진 0개 이상의 유니코드 코드 포인트로 구성된다.
유니코드 코드 포인트는 이스케이프 시퀀스로도 표현될 수 있다. 모든 코드 포인트는 문자열 리터럴에 문자 그대로 나타날 수 있지만, 닫는 따옴표 코드 포인트,
U+005C (역슬래시), U+000D (캐리지 리턴), U+000A (줄 바꿈)는 제외된다. 어떤 코드 포인트든 이스케이프 시퀀스 형태로 나타날 수 있다.
문자열 리터럴은 ECMAScript 문자열 값으로 평가된다. 이러한 문자열 값을 생성할 때 유니코드 코드 포인트는 11.1.1에서 정의된 대로 UTF-16으로 인코딩된다.
Basic Multilingual Plane에 속한 코드 포인트는 문자열의 단일 코드 유닛 요소로 인코딩된다.
그 외의 모든 코드 포인트는 문자열의 두 코드 유닛 요소로 인코딩된다.
<LF>와 <CR>은 LineContinuation의 일부로서 빈 코드 포인트 시퀀스를
생성하는 경우를 제외하고 문자열 리터럴에 나타날 수 없다. 문자열 리터럴의 문자열 값에 이를 포함시키는 올바른 방법은 \n 또는
\u000A와 같은 이스케이프 시퀀스를 사용하는 것이다.
문자열 리터럴은 String 타입의 값을 의미한다.
SV는 문자열 리터럴의 다양한 부분에 재귀적으로 적용되어 문자열 값을 생성한다. 이 과정의 일부로, 문자열 리터럴 내의 일부 유니코드 코드 포인트는 아래 또는
12.9.3에서 설명한 대로 수학적
값을 갖는 것으로 해석된다.
정규 표현식 리터럴은 평가될 때마다 RegExp 객체로 변환되는 입력 요소입니다
(22.2 참조). 프로그램 내의 두
정규 표현식 리터럴은,
두 리터럴의 내용이 동일하더라도 서로 ===로 비교될 때 같지 않은 정규 표현식 객체로 평가됩니다. RegExp 객체는
new RegExp 또는 RegExp 생성자를 함수로 호출하여 런타임에 생성할 수도 있습니다
(22.2.4 참조).
구문 지시 연산
TV는 인수를 받지 않으며 String 또는
undefined를 반환합니다. 템플릿 리터럴 구성 요소는 TV에 의해
String 타입 값으로
해석됩니다. TV는
템플릿 객체의 인덱스드 구성 요소(일상적으로 템플릿 값)를 구성하는 데 사용됩니다. TV에서 이스케이프 시퀀스는 해당 이스케이프 시퀀스가 나타내는 유니코드 코드
포인트의 UTF-16 코드 유닛(들)로 대체됩니다.
구문 지시 연산
TRV는 인수를 받지 않으며 String을 반환합니다. 템플릿 리터럴 구성 요소는 TRV에 의해
String 타입 값으로
해석됩니다. TRV는
템플릿 객체의 원시(raw) 구성 요소(일상적으로 템플릿 원시 값)를 구성하는 데 사용됩니다. TRV는 TV와 유사하지만,
TRV에서는 이스케이프 시퀀스가 리터럴에 나타난 그대로 해석된다는 점이 다릅니다.
대부분의 ECMAScript 문장과 선언은 세미콜론으로 끝나야 합니다. 이러한 세미콜론은 소스 텍스트에 항상 명시적으로 나타낼 수 있습니다. 하지만 편의를 위해, 특정 상황에서는
이러한 세미콜론을 소스 텍스트에서 생략할 수 있습니다. 이러한 상황에서는 세미콜론이 자동으로 소스 코드 토큰 스트림에 삽입된다고 설명합니다.
12.10.1 자동 세미콜론 삽입 규칙
다음 규칙에서 “토큰(token)”은 목표 심볼로 현재 렉시컬 분석에서 인식된 실제 렉시컬 토큰을 의미하며,
이는 12절에 설명되어 있습니다.
세미콜론 삽입의 기본 규칙은 세 가지가 있습니다:
소스 텍스트를 왼쪽에서 오른쪽으로 파싱할 때, 어떤 생산 규칙에도 허용되지 않는 토큰(offending token이라 함)을 만나면,
다음 조건 중 하나라도 참이면 그 토큰 앞에 세미콜론이 자동으로 삽입됩니다:
offending token이 이전 토큰과 하나 이상의 LineTerminator로 구분되어 있는 경우.
offending token이 }인 경우.
이전 토큰이 )이고, 삽입된 세미콜론이 do-while 문(14.7.2)의 종료 세미콜론으로 파싱되는 경우.
소스 텍스트를 왼쪽에서 오른쪽으로 파싱할 때, 토큰 입력 스트림의 끝에 도달하고 파서가 입력 토큰 스트림을 목표 비단말의 단일 인스턴스로 파싱할 수 없는 경우, 입력
스트림의 끝에 세미콜론이 자동으로 삽입됩니다.
소스 텍스트를 왼쪽에서 오른쪽으로 파싱할 때, 어떤 토큰이 문법의 어떤 생산 규칙에 의해 허용되지만, 그 생산 규칙이 제한된 생산(restricted
production)이고 그 토큰이 “[no LineTerminator here]” 주석 바로 다음에 오는 터미널 또는
비단말의 첫 번째 토큰(따라서 restricted token이라 함)이며, 그 restricted token이 이전 토큰과 하나 이상의 LineTerminator로 구분되어 있다면, 해당
restricted token 앞에 세미콜론이 자동으로 삽입됩니다.
하지만, 앞선 규칙들에 대한 추가적인 우선 조건이 있습니다: 세미콜론이 자동으로 삽입되어 빈 문장(empty statement)이 되거나, for문
헤더의 두 세미콜론 중 하나가 되면, 세미콜론은 절대 자동 삽입되지 않습니다(14.7.4 참조).
++ 또는 -- 토큰이 후위 연산자로 처리되는 위치에서, 그 앞에 하나 이상의 LineTerminator가 있으면,
++ 또는 -- 앞에 세미콜론이 자동 삽입됩니다.
continue, break, return,
throw, yield 토큰이 등장하고, 그 다음 토큰 앞에 LineTerminator가 있으면,
해당 토큰 뒤에 세미콜론이 자동 삽입됩니다.
화살표 함수(arrow function) 파라미터 뒤에 LineTerminator가 오고, 그 뒤에
=> 토큰이 오면, 세미콜론이 자동 삽입되고 해당 구두점은 구문 오류를 발생시킵니다.
async 토큰 뒤에 LineTerminator가 오고, 그 다음에
function 또는 IdentifierName 또는 (
토큰이 오면, 세미콜론이 자동 삽입되고 async는 다음 토큰들과 같은 식이나 클래스 요소의 일부로 처리되지 않습니다.
async 토큰 뒤에 LineTerminator가 오고, 그 다음에
* 토큰이 오면, 세미콜론이 자동 삽입되고 해당 구두점은 구문 오류를 발생시킵니다.
이로 인해 ECMAScript 프로그래머에게 실질적으로 권장되는 사항은 다음과 같습니다:
후위 ++ 또는 -- 연산자는 피연산자와 같은 줄에 있어야 합니다.
Expression이
return 또는 throw문에 있거나, AssignmentExpression이
yield 표현식에 있을 때는, 그 시작이 return, throw,
yield 토큰과 같은 줄에 있어야 합니다.
LabelIdentifier가
break 또는 continue 문에 있을 때는, break 또는
continue 토큰과 같은 줄에 있어야 합니다.
화살표 함수의 파라미터 끝과 =>는 같은 줄에 있어야 합니다.
비동기 함수나 메서드 앞의 async 토큰은 바로 뒤 토큰과 같은 줄에 있어야 합니다.
12.10.2 자동 세미콜론 삽입의 예시
이 절은 규범적인 내용이 아닙니다.
다음 소스는
{ 12 } 3
자동 세미콜론 삽입 규칙이 있더라도 ECMAScript 문법에서 유효한 문장이 아닙니다. 반면, 다음 소스
{ 12 } 3
도 ECMAScript 문법상 유효한 문장은 아니지만, 자동 세미콜론 삽입에 의해 다음과 같이 변환됩니다:
{ 1
;2 ;} 3;
이것은 유효한 ECMAScript 문장입니다.
다음 소스
for (a; b
)
는 유효한 ECMAScript 문장이 아니며, 자동 세미콜론 삽입에 의해 변경되지 않습니다. 그 이유는 for 문 헤더에 필요한 세미콜론이기
때문입니다. 자동 세미콜론 삽입은 for 문 헤더의 두 세미콜론 중 하나를 절대 삽입하지 않습니다.
다음 소스
return
a + b
는 자동 세미콜론 삽입에 의해 다음과 같이 변환됩니다:
return;
a + b;
노트 1
a + b 식은 return 문에 의해 반환되는 값으로 처리되지 않습니다. 그 이유는 LineTerminator가
return 토큰과 그 뒤 토큰 사이에 있기 때문입니다.
다음 소스
a = b
++c
는 자동 세미콜론 삽입에 의해 다음과 같이 변환됩니다:
a = b;
++c;
노트 2
++ 토큰은 변수 b에 적용되는 후위 연산자로 처리되지 않습니다. 그 이유는 LineTerminator가
b와 ++ 사이에 있기 때문입니다.
다음 소스
if (a > b)
else c = d
는 유효한 ECMAScript 문장이 아니며, else 토큰 앞에 자동 세미콜론 삽입으로 변경되지 않습니다. 그 이유는 그 경우 자동 삽입된 세미콜론이
빈 문장(empty statement)이 되기 때문입니다.
다음 소스
a = b + c
(d + e).print()
는 자동 세미콜론 삽입에 의해 변환되지 않습니다. 그 이유는 두 번째 줄이 괄호로 시작하는 식이기 때문에, 전체가 함수 호출의 인수 목록으로 해석될 수 있기
때문입니다:
a = b + c(d + e).print()
대입문이 왼쪽 괄호로 시작해야 하는 상황에서는, 자동 세미콜론 삽입에 의존하기보다는 명시적으로 이전 문장의 끝에 세미콜론을 추가하는 것이 좋습니다.
12.10.3 자동 세미콜론 삽입의 흥미로운 사례
이 절은 규범적인 내용이 아닙니다.
ECMAScript 프로그램은 자동 세미콜론 삽입에 의존해 아주 적은 세미콜론만으로 작성될 수도 있습니다. 위에서 설명한 대로, 세미콜론은 모든 줄 바꿈마다 삽입되지 않으며,
자동 세미콜론 삽입은 여러 토큰이 줄 바꿈을 가로지르는지에 따라 달라질 수 있습니다.
ECMAScript에 새로운 문법 기능이 추가됨에 따라, 자동 세미콜론 삽입에 의존하는 라인 앞에서 문법 생산이 달라지는 추가 문법 생산이 추가될 수 있습니다.
이 절에서는, 세미콜론이 삽입될 수도 있고 아닐 수도 있는 위치(즉, 앞선 소스 텍스트에 따라 달라지는 위치)를 자동 세미콜론 삽입의 흥미로운 사례로 간주합니다. 이 절의
나머지 부분에서는 이 버전의 ECMAScript에서 자동 세미콜론 삽입의 여러 흥미로운 사례를 설명합니다.
12.10.3.1 Statement List에서의 자동 세미콜론 삽입의 흥미로운 사례
StatementList에서, 많은
StatementListItem은
세미콜론으로 끝나며, 자동 세미콜론 삽입을 통해 생략할 수 있습니다. 위 규칙의 결과로, 표현식이 끝나는 줄의 끝에서 다음 줄이 아래 항목 중 하나로 시작한다면,
세미콜론이 필요합니다:
ECMAScript에는 “[no LineTerminator here]”를 포함하는 문법 생산이 있습니다.
이러한 생산은 때때로 문법에서 피연산자를 선택적으로 허용하기 위한 수단으로 쓰입니다. 이러한 위치에 LineTerminator를 도입하면, 선택적 피연산자가 없는 문법 생산을
사용하게 되어 문법 생산이 바뀝니다.
이 절의 나머지 부분에서는 이 버전의 ECMAScript에서 “[no LineTerminator here]”를 사용하는 여러 생산을 설명합니다.
12.10.3.2.1 선택적 피연산자와 “[no LineTerminator here]”가 있는 문법 생산 목록
ArrayLiteral은
대괄호로 둘러싸인, 0개 이상의 각 요소가 배열의 원소를 나타내는 표현식으로 이루어진 리스트를 사용하여 배열(Array)의 초기화를 기술하는 표현식이다.
요소들은 반드시 리터럴일 필요는 없으며, 배열 이니셜라이저가 평가될 때마다 각각 평가된다.
배열 요소는 요소 리스트의 시작, 중간, 끝 모두에서 생략될 수 있다. 요소 리스트에서 콤마가 AssignmentExpression 앞에 오지 않는 경우(즉, 시작이거나
또 다른 콤마 뒤), 해당 빠진 배열 요소는 배열의 길이에 기여하며 이후 요소의 인덱스를 증가시킨다. 생략된 배열 요소는 정의되지 않는다. 배열의 끝에 요소가 생략된 경우,
해당 요소는 배열의 길이에 기여하지 않는다.
realm의 프로그램
코드에 있는 각 TemplateLiteral는 태그드 템플릿 평가에 사용되는
고유한 템플릿 객체와 연결되어 있다 (13.2.8.6).
템플릿 객체는 frozen 상태이며, 특정 태그드 템플릿이 평가될 때마다 동일한 템플릿 객체가 사용된다. 템플릿 객체가 TemplateLiteral의 첫
평가 시점에 지연 생성(lazy)되는지 혹은 사전에 미리 생성되는지는 구현 선택 사항이며, ECMAScript 코드에서는 관찰할 수 없다.
참고 3
이 명세의 미래 버전에서는 템플릿 객체의 추가적인 non-enumerable 프로퍼티가 정의될 수 있다.
13.2.8.5 런타임 의미론: SubstitutionEvaluation
구문 지향 연산
SubstitutionEvaluation은 인수를 받지 않으며, 리스트나
비정상 완료를 반환한다. 다음
생산식들에 대해 정의된다:
호스트
정의 추상 연산 HostFinalizeImportMeta는 importMeta (객체)와
moduleRecord (모듈 레코드(Module Record))를 인수로
받고 unused를 반환한다. 이 연산은 호스트가 import.meta에서 반환되는 객체를 ECMAScript
코드에 노출하기 전에 특별한 처리를 할 수 있도록 한다.
대부분의 호스트는 HostGetImportMetaProperties만
정의하고, HostFinalizeImportMeta는 기본 동작을 사용하면 된다. 그러나 HostFinalizeImportMeta는 호스트가 객체를 직접 조작해야 할 경우를 위한
"탈출구"를 제공한다.
delete 연산자가 strict mode 코드 내에서 등장하면, 그
UnaryExpression이 변수, 함수 인수, 또는 함수
이름에 대한 직접 참조인 경우 SyntaxError 예외가 발생한다. 또한, delete
연산자가 strict mode 코드 내에 있고 삭제 대상 프로퍼티의
속성이 { [[Configurable]]: false }(또는 삭제할 수
없는 경우)이면 TypeError 예외가 발생한다.
참고 2
4.c 단계에서 생성될 수 있는 객체는
위의 추상 연산과 일반 객체[[Delete]] 내부 메서드 외부에서는 접근할 수 없다. 실제 구현에서는 실제로 객체를 생성하지 않을
수도 있다.
동등 연산자는 항상 추이적이지 않다. 예를 들어 동일한 문자열 값을 갖는 두 개의 서로 다른 String 객체가 있을 수 있다. 각 String 객체는
== 연산자에 의해 그 문자열 값과 동등하게 평가되지만, 두 String 객체끼리는 동등하지 않다. 예시:
new String("a") == "a" 및 "a" == new String("a")는 모두
true이다.
new String("a") == new String("a")는 false이다.
참고 4
문자열의 비교는 코드 유닛 값 시퀀스에 대한 단순 동등성 테스트를 사용한다. 유니코드 명세에 정의된 문자 또는 문자열 동등성 및 정렬 순서의 더 복잡한 의미론적
정의를 사용하지 않는다. 따라서 유니코드 표준에 따라 정규화된 문자열 값이라도 서로 다르다고 평가될 수 있다. 사실상 이 알고리즘은 두 문자열이 이미 정규화된
형태임을 전제로 한다.
ECMAScript에서 ConditionalExpression의 문법은 C와 Java와
약간 다릅니다. C와 Java는 두 번째 부분식에 Expression을 허용하지만, 세 번째 식은 ConditionalExpression으로 제한합니다.
ECMAScript에서 이 차이를 둔 이유는 조건문의 어느 쪽 분기에도 할당식을 둘 수 있도록 하고, 가운데 식으로 콤마 식이 오는 혼란스럽고 거의 쓸모없는 경우를
없애기 위함입니다.
이 표현식이 strict mode 코드 내에 있을 때, 1.e,
3,
2,
2,
2
단계의 lRef가 해결할 수 없는 참조라면 런타임 오류가 발생하며, ReferenceError 예외가
throw된다. 또한 9,
6,
6,
6
단계의 lRef가 데이터 프로퍼티로서 { [[Writable]]: false } 속성을 갖거나, 접근자
프로퍼티로서 { [[Set]]:
undefined } 속성을 갖거나, IsExtensible가
false를 반환하는 객체의 존재하지 않는 프로퍼티라면 TypeError 예외가
throw된다.
추상 연산 ApplyStringOrNumericBinaryOperator는 lVal (ECMAScript 언어 값), opText
(**, *, /, %,
+, -, <<, >>,
>>>, &, ^, 또는 |),
rVal (ECMAScript 언어 값)을 인수로 받으며, String,
BigInt 또는 Number가 담긴 정상 완료 또는
throw completion를 반환한다.
호출 시 다음 단계를 수행한다:
단계 ToPrimitive의 호출에는 힌트가 제공되지 않는다(1.a, 1.b). 표준 객체(날짜 객체 제외)는
힌트가 없으면 number가 주어진 것처럼 동작하며, 날짜 객체는
string이 주어진 것처럼 동작한다. Exotic 객체는 힌트가 없을 때 다르게 동작할 수
있다.
environment에 undefined가 전달되는 경우, 초기화 값을 할당하기 위해
PutValue 연산을 사용해야 함을 나타낸다. 이는 비엄격
함수(non-strict functions)의 형식적 매개변수 리스트의 경우이다. 이런 경우, 동일한 이름의
여러 매개변수가 있을 수 있으므로 형식적 매개변수 바인딩이 미리 초기화된다.
environment에 undefined가 전달되면, 초기화 값을 할당하기 위해 PutValue
연산을 사용해야 함을 나타낸다. 이는 var 문과 일부 비엄격 함수(non-strict
functions)의 형식적 매개변수 리스트의 경우이다( 10.2.11 참조). 이러한
경우, 렉시컬 바인딩이 호이스팅되고 초기화자 평가 전에 미리 초기화된다.
이터레이터 객체를 반환한다. 이 객체의
next 메서드는 O의 열거 가능한 프로퍼티의 모든 문자열 키를 순회한다. 이터레이터 객체는 ECMAScript 코드에서 직접
접근할 수 없다. 프로퍼티 열거의 메커니즘과 순서는 명시되어 있지 않지만, 아래 명시된 규칙을 따라야 한다.
이터레이터의 throw 및
return 메서드는 null이며, 호출되지 않는다. 이터레이터의 next 메서드는 객체의
프로퍼티가 프로퍼티
키로 반환되어야 하는지 판별한다. 반환되는 프로퍼티 키에는 심볼(Symbol) 키가 포함되지 않는다.
대상 객체의 프로퍼티는 열거 도중 삭제될 수 있다. 이터레이터의 next 메서드가 처리하기 전에
삭제된 프로퍼티는 무시된다. 열거 도중 새 프로퍼티가 추가된 경우, 새로 추가된 프로퍼티가 반드시 열거될 필요는 없다. 프로퍼티 이름은 어떤
열거에서도 이터레이터의 next 메서드에서 최대 한 번만
반환된다.
대상 객체의 프로퍼티를 열거할 때, 프로토타입, 프로토타입의 프로토타입 등도 재귀적으로 열거 대상에 포함된다. 단, 프로토타입의 프로퍼티가 이터레이터의 next 메서드에 의해 이미
처리된 이름과 같은 경우는 건너뛴다. 프로토타입 객체의 [[Enumerable]] 속성 값은 이미 처리된 프로퍼티 판정에
고려되지 않는다. 프로토타입 객체의 열거 가능한 프로퍼티 이름은 EnumerateObjectProperties를 해당 프로토타입 객체에 대해 호출하여 얻어야 한다.
EnumerateObjectProperties는 대상 객체의 [[OwnPropertyKeys]] 내부 메서드를 호출하여
자신의 프로퍼티
키를 얻어야 한다. 프로퍼티 속성 정보는 [[GetOwnProperty]] 내부
메서드를 호출하여 얻어야 한다.
for-in
이터레이터는 특정 객체에 대한 특정 반복(iteration)을 나타내는 객체이다. for-in 이터레이터 객체는 ECMAScript 코드에서 직접
접근할 수 없으며, EnumerateObjectProperties의
동작을 설명하기 위한 목적으로만 존재한다.
14.7.5.10.1 CreateForInIterator ( object )
추상 연산 CreateForInIterator는 인수 object (객체)를 받고, for-in 이터레이터를 반환한다. 이 연산은
object의 자신의 및 상속받은 열거 가능한 문자열 프로퍼티를 특정 순서로 순회하는 for-in 이터레이터 객체를 생성한다. 호출 시
다음 단계를 수행한다:
return 문은 함수의 실행을 중단시키고, 대부분의 경우 호출자에게 값을 반환한다. Expression이 생략되면 반환 값은
undefined이다. 그렇지 않으면 반환 값은 Expression의 값이다. return 문은 주변 문맥에
따라 실제로는 호출자에게 값을 반환하지 않을 수도 있다. 예를 들어 try 블록에서 return
문이 실행될 때는 Completion Record가
finally 블록 평가 중에 다른 Completion
Record로 대체될 수 있다.
Statement는 레이블로 접두사를 붙일 수 있다.
레이블문은 레이블이 붙은 break 및 continue 문과 함께 사용할 때만 쓰인다. ECMAScript에는
goto 문이 없다. Statement는 LabelledStatement의 일부일 수 있으며, 이는 다시
LabelledStatement의
일부일 수도 있고, 계속 반복된다. 이렇게 도입된 레이블들은 개별 문들의 의미를 설명할 때 "현재 레이블 집합(current label set)"이라고 한다.
ArrowFunction은
arguments, super, this, new.target에
대한 지역 바인딩을 정의하지 않는다. ArrowFunction 내에서
arguments, super, this, new.target에
대한 참조는 반드시 렉시컬 상위 환경의 바인딩을 참조해야 한다. 일반적으로 이는 바로 상위 함수의 Function Environment가 된다. ArrowFunction이
super를 포함하더라도, 함수 객체는 5단계에서
MakeMethod를 통해 메서드로 만들어지지 않는다. ArrowFunction이
super를 참조하는 경우, 반드시 비-ArrowFunction 내에 포함되어 있고, 함수
객체가 캡처한 env를 통해 super를 구현하는 데 필요한 상태를 접근할
수 있다.
Record { [[Key]]: propKey, [[Closure]]: closure }를 반환한다.
15.4.5 런타임 의미론: MethodDefinitionEvaluation
구문 지시 연산
MethodDefinitionEvaluation은 인수 object(Object)와 enumerable(Boolean)을 받고,
정상 완료(PrivateElement 또는
unused), 또는 비정상 완료를
반환한다. 다음 생성식에 대해 조각별로 정의된다:
PrivateBoundIdentifiers
of ClassElementList에
중복된 항목이 존재하는 경우(단, 이름이 게터와 세터에 각각 한 번씩만 사용되고, 그 외에는 사용되지 않으며, 게터와 세터가 모두 static이거나 모두
static이 아니면 예외), 문법 오류입니다.
명세의 편의를 위해, private 메서드와 접근자는 클래스 인스턴스의 [[PrivateElements]] 슬롯에
private 필드와 함께 포함되어 있습니다.
그러나 어떤 객체든 주어진 클래스에 의해 정의된 모든 private 메서드와 접근자를 가지거나, 아무것도 가지지 않습니다.
이 기능은 구현이 각 메서드 또는 접근자를 개별적으로 추적할 필요 없이, private 메서드와 접근자를 구현할 수 있도록 설계되었습니다.
예를 들어, 구현체는 인스턴스 private 메서드를 해당 Private Name에 직접 연결하고,
각 객체에 대해 어떤 클래스 생성자가 해당 객체를 this 값으로 실행했는지 추적할 수
있습니다.
객체에서 인스턴스 private 메서드를 조회하는 것은, 해당 메서드를 정의한 클래스 생성자가 객체를 초기화했는지 확인하고,
Private
Name에 연결된 메서드를 반환하는 것으로 구성됩니다.
이는 private 필드와는 다릅니다: 필드 이니셜라이저가 클래스 인스턴스화 중에 throw될 수 있기 때문에,
개별 객체는 주어진 클래스의 private 필드의 일부만 가질 수 있으므로, private 필드는 일반적으로 개별적으로 추적되어야 합니다.
참고: 이 분기는 constructor(...args) { super(...args); }와
비슷하게 동작합니다. 가장 눈에 띄는 차이점은 위 ECMAScript 소스 텍스트가 %Symbol.iterator%를
%Array.prototype%에서 호출하는 반면,
이 함수는 호출하지 않는다는 점입니다.
꼬리 위치 호출은 대상 함수를 호출하기 전에 현재 실행 중인 함수의 execution context와 연관된 임시 내부 리소스를 해제하거나,
그 리소스를 대상 함수 지원에 재사용해야 한다.
참고
예를 들어, 꼬리 위치 호출은 구현의 activation record 스택을 대상 함수의 activation record 크기가 호출 함수의 activation
record 크기를 초과하는 만큼만 증가시켜야 한다.
만약 대상 함수의 activation record가 더 작다면 전체 스택 크기는 줄어야 한다.
추상 연산 ParseScript는 sourceText (ECMAScript 소스 텍스트), realm (Realm 레코드),
hostDefined (아무 값) 인자를 받아 스크립트 레코드 또는 List (비어있지 않은
SyntaxError 객체 목록)을 반환한다. sourceText를 Script로 파싱한 결과에 기반하여 스크립트 레코드를 생성한다. 호출 시 다음 단계를 수행한다:
초기 에러는
16.1.1에서 함수/var
선언과 let/const/class 선언 간의 이름 충돌 및 단일 Script 내에서의 let/const/class 바인딩 재선언을 방지한다. 그러나
여러 Script에 걸친 충돌 및 재선언은
GlobalDeclarationInstantiation 실행 중 런타임 에러로 감지된다. 이러한 에러가 감지되면 스크립트에 대해 어떤 바인딩도 인스턴스화되지
않는다. 하지만 global object가 Proxy
exotic object로 정의된 경우, 런타임 충돌 선언 검사가 신뢰할 수 없어 비정상 완료(abrupt
completion)와 일부 글로벌 선언이 인스턴스화되지 않을 수 있다.
이 경우 Script의 코드는 평가되지 않는다.
명시적인 var 또는 function 선언과 달리, global object에 직접 생성된 프로퍼티는
let/const/class 선언에 의해 그림자 처리될 수 있다.
추상 연산 ImportedLocalNames는 importEntries(List of ImportEntry
Record)를 인자로 받고, 문자열 List를 반환한다.
importEntries로 정의된 모든 지역 이름 바인딩의 List를 생성한다. 호출 시 다음
단계를 수행한다:
Module Record는 단일 모듈의 import와 export에 대한
구조적 정보를 캡슐화한다. 이 정보는 연결된 모듈 집합의 import와 export를 연결하는 데 사용된다. Module Record는 모듈을 평가할 때만 사용하는
네 개의 필드를 포함한다.
명세 목적상 Module Record 값은 Record
명세 타입의 값이며, Module Record가 추상 클래스이고 추상 및 구체 서브클래스를 가진 단순 객체지향 계층에 존재한다고 생각할 수 있다. 이 명세서는
Cyclic
Module Record라는 추상 서브클래스와 Source Text Module
Record라는 구체 서브클래스를 정의한다. 다른 명세와 구현체들은 자신들이 정의한 대안적 모듈 정의 기능에 대응하는
추가적인 Module Record 서브클래스를 정의할 수 있다.
Module Record는 표 43에 나열된 필드를 정의한다. 모든 Module
Definition 서브클래스는 최소한 이 필드들을 포함한다. 또한 Module Record는 표 44에 나열된 추상 메서드 목록을
정의한다. 모든 Module Definition 서브클래스는 이 추상 메서드들의 구체 구현을 제공해야 한다.
이 메서드를 호출하기 전에 LoadRequestedModules가 성공적으로 완료되어야 한다.
ResolveExport(exportName [, resolveSet])
이 모듈에서 export된 이름의 바인딩을 반환한다. 바인딩은 { [[Module]]: Module
Record, [[BindingName]]: String |
namespace } 형태의 ResolvedBinding Record로 표현된다. 만약 export가 어떤
모듈에도 직접 바인딩되지 않은 Module Namespace Object라면 [[BindingName]]은
namespace로 설정된다. 이름을 해결할 수 없으면
null을, 여러 바인딩이 발견되면
ambiguous를 반환한다.
이 연산이 특정 exportName, resolveSet 쌍으로 호출될 때마다 같은
결과를 반환해야 한다.
이 메서드를 호출하기 전에 LoadRequestedModules가 성공적으로 완료되어야 한다.
이 메서드를 호출하기 전에 LoadRequestedModules가 성공적으로 완료되어야 한다.
Evaluate()
이 모듈과 그 의존성의 평가에 대한 프라미스를 반환한다. 평가가 성공하거나 이미 성공적으로 평가된 경우 resolve되며,
평가 에러가 발생하거나 이미 실패한 경우 reject된다. 프라미스가 reject될 경우 호스트는
프라미스 reject를 처리하고 평가 에러를 다시 throw해야 한다.
new, unlinked,
linking, linked,
evaluating,
evaluating-async, 또는
evaluated
처음에는 new입니다. 모듈의 생애 주기 동안
unlinked, linking,
linked, evaluating, 경우에 따라
evaluating-async,
evaluated로(그 순서로) 전이됩니다. evaluating-async는 이 모듈이 비동기 의존성이 완료된 후 실행 대기 중이거나
[[HasTLA]] 필드가 true인 모듈로서
실행되었고, 최상위 완료를 대기 중임을 나타냅니다.
이 레코드가 나타내는 모듈이 상대적 import 속성을 가지고 모듈을 import 요청할 때 사용한 specifier 문자열에서
Module
Record로 매핑되는 정보입니다. 리스트에는 Recordsr1과 r2가 존재하지 않습니다. ModuleRequestsEqual(r1,
r2)가 true인 경우.
사이클 내에서 처음 방문한 모듈, 강하게 연결된 구성 요소의 루트 DFS 조상입니다. 사이클에 속하지 않은 모듈의 경우 자신이
됩니다. Evaluate가 완료된 후, 모듈의 [[DFSAncestorIndex]]는
[[CycleRoot]]의 깊이 우선 탐색 인덱스가 됩니다.
[[HasTLA]]
Boolean
이 모듈이 개별적으로 비동기적인지 여부(예: 최상위 await가 포함된 Source Text Module
Record일 경우). 비동기 의존성이 있다고 해서 이 필드가
true가 되는 것은 아닙니다. 이 필드는 모듈이 파싱된 이후에 변경되면 안 됩니다.
이 필드는 처음에 unset으로 설정되며, 완전히 동기적인 모듈의 경우 계속
unset입니다. 모듈 자체가 비동기이거나 비동기 의존성을 가진 경우, integer로 설정되어 16.2.1.6.1.3.4에
의해 대기 중인 모듈 실행 순서를 결정합니다. 대기 모듈이 실행되면 done으로
설정됩니다.
이 모듈이 어떤 사이클의 [[CycleRoot]]이고, 그 사이클의 모듈 중 하나에
대해 Evaluate()가 호출된 경우, 이 필드는 전체 평가에 대한 PromiseCapability
Record를 포함합니다. 이는 Evaluate() 추상 메서드에서 반환되는
Promise 객체를 해결하는 데 사용됩니다. 해당 모듈의 의존성에는 empty가 되며,
일부 의존성에 대해 최상위 Evaluate()가 시작된 경우를 제외합니다.
순환 모듈 레코드module의
LoadRequestedModules 구체적인 메서드는 선택적 인자 hostDefined(임의 값)을 받고 Promise를
반환합니다. 이 메서드는 module의 의존성 그래프에 있는 모든 모듈 레코드의 [[LoadedModules]]를 채웁니다(대부분의 작업은 보조 함수 InnerModuleLoading에서 수행됩니다).
선택적 hostDefined 파라미터는 HostLoadImportedModule 훅에
전달됩니다. 호출 시 다음과 같은 절차를 수행합니다:
hostDefined 인자는 import된 모듈을 가져오는데 필요한 추가 정보를 전달하는 데 사용할 수 있습니다. 예를 들어
HTML에서는 <link rel="preload" as="..."> 태그에 대해 올바른 fetch
destination을 설정하는 데 사용합니다.
import() 표현식에서는 hostDefined 인자를 절대 설정하지 않습니다.
추상 연산 InnerModuleLoading은 state(GraphLoadingState
Record)와 module(모듈 레코드)를 인자로 받고,
unused를 반환합니다. LoadRequestedModules에서 module의
의존성 그래프에 대해 실제 로딩 과정을 재귀적으로 수행할 때 사용됩니다. 호출 시 다음과 같은 절차를 수행합니다:
! Call(state.[[PromiseCapability]].[[Reject]],
undefined, « moduleCompletion.[[Value]] »)를 수행한다.
unused를 반환한다.
16.2.1.6.1.2 Link ( )
순환 모듈 레코드module의
Link 구체적 메서드는 인자를 받지 않으며, 정상 완료(normal
completion)로 unused를 포함하거나 throw
completion를 반환합니다. 성공 시 Link는 이 모듈의 [[Status]]를 unlinked에서
linked로 전이시킵니다. 실패 시 예외가 throw되고 이 모듈의 [[Status]]는 unlinked 상태로 남습니다. (대부분의
작업은 보조 함수 InnerModuleLinking에서 수행됩니다.)
호출 시 다음의 절차를 수행합니다:
Assert: module.[[Status]]는 unlinked,
linked, evaluating-async, 또는
evaluated 중 하나이다.
16.2.1.6.1.2.1 InnerModuleLinking (
module, stack, index )
추상 연산 InnerModuleLinking은 module(모듈 레코드),
stack(List of
순환 모듈 레코드),
index(음이 아닌 integer) 인자를 받아, 정상 완료(normal
completion)로 음이 아닌 integer를 포함하거나 throw
completion를 반환합니다. Link에서 module의 실제 linking
과정을 수행하며, 의존성 그래프의 다른 모든 모듈에 대해 재귀적으로 동작합니다. stack, index
인자와 모듈의 [[DFSAncestorIndex]] 필드는 깊이 우선 탐색(DFS) 과정을 추적하는
데 사용됩니다. 특히 [[DFSAncestorIndex]]는 강하게 연결된 구성 요소(SCC)를
찾기 위한 용도로 활용되어, SCC 내의 모든 모듈이 함께 linked로 전이됩니다. 호출 시 다음의
절차를 수행합니다:
requiredModule과 module이 동일한
모듈
레코드이면 done을
true로 설정한다.
index를 반환한다.
16.2.1.6.1.3 Evaluate ( )
순환 모듈 레코드module의
Evaluate 구체적 메서드는 인자를 받지 않으며 Promise를 반환합니다. Evaluate는 이 모듈의 [[Status]]를 linked에서
evaluating-async 또는 evaluated로 전이시킵니다.
해당 강하게 연결된 구성 요소 내의 모듈에 대해 처음 호출될 때, Evaluate는 모듈 평가가 완료될 때 resolve되는 Promise를 생성하여
반환합니다. 이 Promise는 해당 구성 요소의 [[CycleRoot]]의 [[TopLevelCapability]] 필드에 저장됩니다. 이후 해당 구성 요소 내의 어떤 모듈에 대해
Evaluate를 호출해도 동일한 Promise를 반환합니다. (대부분의 작업은 보조 함수 InnerModuleEvaluation에서
수행됩니다.) 호출 시 다음 절차를 수행합니다:
Assert: 이 Evaluate 호출은 주변
에이전트 내에서 다른 Evaluate 호출과 동시에 발생하지 않는다.
Assert: module.[[Status]]는 linked,
evaluating-async 또는 evaluated
중 하나이다.
module.[[Status]]가
evaluating-async 또는
evaluated라면, module을
module.[[CycleRoot]]로 설정한다.
그 밖의 경우 requiredModule.[[Status]]를
evaluating-async로 설정한다.
requiredModule과 module이 동일한
모듈
레코드이면 done을
true로 설정한다.
requiredModule.[[CycleRoot]]를
module로 설정한다.
index를 반환한다.
Note 1
모듈은 InnerModuleEvaluation에 의해 순회되는 동안 evaluating
상태이며, 실행이 끝나면 evaluated 상태가 되고, [[HasTLA]] 필드가 true이거나 비동기
의존성이 있을 경우 실행 중 evaluating-async 상태가 됩니다.
Note 2
비동기 사이클의 모듈에 의존하는 모든 모듈은 해당 사이클이 evaluating 상태가 아닐
때, [[CycleRoot]]를 통해 사이클의 루트 실행에 의존하게 됩니다. 이를
통해 사이클의 상태를 루트 모듈 상태를 통해 하나의 강하게 연결된 구성 요소로 취급할 수 있습니다.
16.2.1.6.1.3.2 ExecuteAsyncModule (
module )
추상 연산 ExecuteAsyncModule은 module(순환 모듈 레코드) 인자를 받아
unused를 반환합니다. 호출 시 다음 절차를 수행합니다:
Assert: module.[[Status]]는 evaluating 또는
evaluating-async 중 하나이다.
참고: module.[[AsyncEvaluationOrder]]는
AsyncModuleExecutionFulfilled와의
대칭성을 위해 done로 설정됩니다. InnerModuleEvaluation에서는
모듈의 [[EvaluationError]] 내부 슬롯이
empty가 아니면 [[AsyncEvaluationOrder]] 내부 슬롯 값은 사용되지 않습니다.
module.[[AsyncParentModules]]의 각
순환 모듈 레코드m에 대해 다음을 수행한다:
Assert:
module.[[CycleRoot]]와
module은 동일한 모듈
레코드이다.
! Call(module.[[TopLevelCapability]].[[Reject]],
undefined, « error »)를 수행한다.
unused를 반환한다.
16.2.1.6.2 순환 모듈 레코드 그래프 예시
이 비규범 섹션에서는 몇 가지 일반적인 모듈 그래프의 연결(linking) 및 평가(evaluation) 예시를 시리즈로 보여주며, 특히 오류가 어떻게 발생할
수 있는지에 중점을 둡니다.
먼저 다음과 같은 간단한 모듈 그래프를 생각해 보겠습니다:
그림 2: 간단한 모듈 그래프
먼저 오류 조건이 없다고 가정해 봅시다. 호스트가 처음으로 A.LoadRequestedModules()를 호출하면,
가정에 따라 성공적으로 완료되고, B와 C의 의존성도 재귀적으로 로드됩니다(각각 C 및 없음).
그리고 A.[[Status]] = B.[[Status]] = C.[[Status]] =
unlinked로 설정됩니다. 이후 호스트가 A.Link()를 호출하면, 다시 가정에 따라 성공적으로 완료되어
A.[[Status]] = B.[[Status]] = C.[[Status]] =
linked가 됩니다. 이러한 준비 단계는 언제든 수행할 수 있습니다. 나중에 호스트가 모듈의 부작용이 발생할 수 있는 시점에 A.Evaluate()를
호출하면, 성공적으로 완료되어 Promise가 undefined로 resolve되고, 먼저 C 다음에
B가 평가됩니다. 이 시점에서 각 모듈의 [[Status]]는
evaluated입니다.
그 다음 성공적으로 A.LoadRequestedModules()를 호출한 뒤 연결(linking) 오류가 발생하는 경우를 생각해 봅시다.
만일 InnerModuleLinking이 C에서
성공하지만, 이후 B에서 실패한다면(예를 들어 B가 C가 제공하지 않는 것을 import하는
경우), 원래의 A.Link()는 실패하고, A와 B의 [[Status]]는 unlinked인 상태로 남습니다.
C의 [[Status]]는 linked가 됩니다.
마지막으로, Link()를 성공적으로 호출한 뒤 평가 오류가 발생하는 경우를 생각해 보겠습니다. 만일 InnerModuleEvaluation이
C에서 성공하지만, 이후 B에서 실패한다면(예를 들어 B가 예외를 던지는 코드를 포함하는 경우),
원래의 A.Evaluate()는 실패하여 rejected Promise를 반환하게 됩니다. 결과적인 예외는 A와
B의 [[EvaluationError]] 필드에 저장되고, 두 모듈의 [[Status]]는 evaluated가 됩니다. C도
evaluated가 되지만, A와 B와 달리 [[EvaluationError]] 없이 성공적으로 평가를 완료합니다. 예외를 저장하는 것은 호스트가 A나
B를 Evaluate()로 재사용하려 할 때 항상 동일한 예외를 만나도록 보장합니다. (호스트는 순환 모듈
레코드를 반드시 재사용할 필요는 없으며, 호스트가 해당 메서드에서 던져진 예외 객체를 반드시 노출할 필요도 없습니다. 하지만 명세상
이러한 동작이 가능하도록 되어 있습니다.)
평가(Evaluation)는 부작용이 있을 수 있으므로 반드시 한
번만 수행되어야 하며, 평가가 이미 수행됐는지(성공하지 않았더라도) 기억하는 것이 중요합니다. (오류의 경우에도 예외를 기억하는 것이 합리적인데,
그렇지 않으면 이후 Evaluate() 호출마다 새 예외를 생성해야 합니다.)
반면 연결(linking)은 부작용이 없으므로 실패하더라도 나중에 재시도해도 문제가 없습니다.
로딩은 호스트와 밀접하게
상호작용하며, 호스트에 따라 실패한 로딩을 재시도할 수 있도록 하는 것이 바람직할 수 있습니다.(예: 네트워크 장애 등 일시적 문제일 경우)
이제 사이클이 있는 모듈 그래프를 생각해 봅시다:
그림 4: 순환 모듈 그래프
여기서는 진입점이 A 모듈이라고 가정합니다. 호스트가 A.LoadRequestedModules()를 호출하면
InnerModuleLoading이 A에
대해 실행됩니다. 이것은 다시 B와 C에 대해 InnerModuleLoading을
호출합니다. 사이클 때문에 다시 InnerModuleLoading이 A에
대해 트리거되지만, 이 시점에서는 A의 의존성 로딩이 이미 시작됐으므로 아무 작업도 하지 않습니다(no-op). 그래프의 모든 모듈이
성공적으로 로드되면 이들의 [[Status]]가 동시에 new에서
unlinked로 전이됩니다.
그 다음 호스트가
A.Link()를 호출하면 InnerModuleLinking이 A에
대해 실행됩니다. 이것은 다시 B에 대해 InnerModuleLinking을 호출합니다. 사이클 때문에
다시 InnerModuleLinking이 A에
대해 트리거되지만, 이 시점에서는 A.[[Status]]가 이미
linking이므로 아무 작업도 하지 않습니다(no-op). B.[[Status]] 자체는 linking 상태로 남아 있다가 제어가 다시 A로
돌아오면 C에 대해 InnerModuleLinking이 트리거됩니다.
C.[[Status]]가 linked가 되고 나면
A와 B가 함께 linking에서
linked로 전이됩니다. 이는 두 모듈이 강하게 연결된 구성 요소이기 때문입니다. 모듈 그래프가 깊이우선탐색으로
순회되는 이 단계에서는 SCC 내의 모듈들을 동시에 상태 전이시킬 수 있습니다.
성공 케이스에서는 순환 모듈 그래프의 평가(evaluation) 단계도 위와 유사하게 동작합니다.
이제 A에 연결 오류가 있는 경우를 생각해 보겠습니다. 예를 들어 A가 C에 존재하지 않는 바인딩을
import하려고 하는 경우입니다. 이 경우 위의 단계는 여전히 발생하며, InnerModuleLinking의
두 번째 호출에서 조기 반환(early return)이 있습니다. 그러나 원래의 InnerModuleLinking에
다시 되돌아오면, InitializeEnvironment(특히 C.ResolveExport() 직후)에서 실패하게 됩니다. 던져진
SyntaxError 예외는 A.Link까지 전파되고, 이때 현재 스택에 있는 모든 모듈(항상 아직
linking 상태인 모듈들)을 reset합니다. 따라서 A와 B는
unlinked가 됩니다. C는 linked 상태로
남습니다.
또는 A에 평가 오류가 있는 경우(예: 소스 코드가 예외를 던지는 경우)를 생각해 봅니다. 이 경우 평가 단계에서도 위와 유사한 과정이
발생하며, InnerModuleEvaluation의 두 번째
호출에서 조기 반환이 있습니다. 원래의 InnerModuleEvaluation에 되돌아오면,
가정에 따라 실패하게 됩니다. 던져진 예외는 A.Evaluate()까지 전파되고, 이때 현재 스택에 있는 모든 모듈(아직
evaluating 상태인 모듈들)과 [[AsyncParentModules]]를 통해, 의존성 그래프 전체에서 최상위 await를
포함하거나 의존하는 모듈 체인에도 오류가 기록됩니다(AsyncModuleExecutionRejected
알고리즘을 통해). 따라서 A와 B는 evaluated가 되고, 예외가
A와 B의 [[EvaluationError]] 필드에 기록되며,
C는 evaluated이지만 [[EvaluationError]]는 없습니다.
마지막으로, 모든 모듈이 비동기적으로 완료되는 사이클이 있는 모듈 그래프를 생각해 봅시다:
그림 5: 비동기 순환 모듈 그래프
로딩 및 연결은 이전과 같이 진행되며, 모든 모듈의 [[Status]]는
linked가 됩니다.
A.Evaluate()를 호출하면 InnerModuleEvaluation이
A, B, D에 대해 호출되어 모두 evaluating
상태로 전이됩니다. 그 후 InnerModuleEvaluation이
A에 대해 한 번 더 호출되지만 이미 evaluating 상태이므로 아무 작업도 하지
않습니다(no-op). 이 시점에서 D.[[PendingAsyncDependencies]]가
0이므로 ExecuteAsyncModule(D)가
호출되고, D.ExecuteModule이 새로운 PromiseCapability와 함께 호출되어 D의 비동기 실행을
추적합니다. 다시 InnerModuleEvaluation로 돌아가서
B에 대해 B.[[PendingAsyncDependencies]]를 1로,
B.[[AsyncEvaluationOrder]]를 1로 설정합니다. 다시 InnerModuleEvaluation의 원래 호출로
돌아가서 A의 [[PendingAsyncDependencies]]를 1로 설정합니다. 다음
반복에서 A의 의존성 루프가 끝나면 InnerModuleEvaluation이
C에 대해, 그리고 D(다시 no-op), E에 대해 호출됩니다. E는 의존성이
없고 사이클에도 포함되지 않으므로 ExecuteAsyncModule(E)가
D와 동일하게 호출되고 E는 바로 스택에서 제거됩니다. 다시 한 번 InnerModuleEvaluation의
C 호출로 돌아와 C.[[AsyncEvaluationOrder]]를 3으로
설정합니다. 이제 A의 의존성 루프가 끝나면 A.[[AsyncEvaluationOrder]]를 4로 설정하고, 전체 SCC를 스택에서 제거하여 모든 모듈이 동시에
evaluating-async로 전이됩니다. 이 시점에서 모듈들의 필드는 표 48에 나옵니다.
표 48: 초기 Evaluate() 호출 후 모듈 필드
필드모듈
A
B
C
D
E
[[DFSAncestorIndex]]
0
0
0
0
4
[[Status]]
evaluating-async
evaluating-async
evaluating-async
evaluating-async
evaluating-async
[[AsyncEvaluationOrder]]
4
1
3
0
2
[[AsyncParentModules]]
« »
« A »
« A »
« B, C »
« C »
[[PendingAsyncDependencies]]
2 (B 및 C)
1 (D)
2 (D 및 E)
0
0
E가 먼저 실행을 완료했다고 가정합니다. 이때 AsyncModuleExecutionFulfilled가
호출되고 E.[[Status]]가 evaluated로
설정되며 C.[[PendingAsyncDependencies]]가 1로 감소합니다. 업데이트된
모듈들의 필드는 표 49에 나옵니다.
표 49: 모듈 E 실행 완료 후 모듈 필드
필드모듈
C
E
[[DFSAncestorIndex]]
0
4
[[Status]]
evaluating-async
evaluated
[[AsyncEvaluationOrder]]
3
done
[[AsyncParentModules]]
« A »
« C »
[[PendingAsyncDependencies]]
1 (D)
0
D가 다음으로 실행을 완료합니다(아직 실행 중인 유일한 모듈이었음). 이때 AsyncModuleExecutionFulfilled가
다시 호출되고 D.[[Status]]가
evaluated로 설정됩니다. 실행 가능한 상위 모듈은 B([[AsyncEvaluationOrder]]가 1)와 C([[AsyncEvaluationOrder]]가 3)로, B가 먼저 처리됩니다:
B.[[PendingAsyncDependencies]]가 0으로 감소하고 ExecuteAsyncModule가
B에 호출되어 실행을 시작합니다. C.[[PendingAsyncDependencies]] 역시 0으로 감소하고 C도 실행을
시작합니다(만약 B에 await가 있으면 C와 병렬로 실행될 수 있음). 업데이트된 모듈들의
필드는 표 50에 나옵니다.
표 50: 모듈 D 실행 완료 후 모듈 필드
필드모듈
B
C
D
[[DFSAncestorIndex]]
0
0
0
[[Status]]
evaluating-async
evaluating-async
evaluated
[[AsyncEvaluationOrder]]
1
3
done
[[AsyncParentModules]]
« A »
« A »
« B, C »
[[PendingAsyncDependencies]]
0
0
0
C가 다음으로 실행을 완료했다고 가정합니다. 이때 AsyncModuleExecutionFulfilled가
다시 호출되어 C.[[Status]]가
evaluated로 설정되고 A.[[PendingAsyncDependencies]]가 1로 감소합니다. 업데이트된 모듈들의 필드는 표 51에 나옵니다.
마지막으로 A가 실행을 완료합니다. 이때 AsyncModuleExecutionFulfilled가
다시 호출되어 A.[[Status]]가
evaluated로 설정됩니다. 이 시점에서 A.[[TopLevelCapability]]의 Promise(A.Evaluate()에서 반환된
Promise)가 resolve되어 이 모듈 그래프의 처리가 종료됩니다. 업데이트된 모듈의 필드는 표 53에 나옵니다.
표 53: 모듈 A 실행 완료 후 모듈 필드
필드모듈
A
[[DFSAncestorIndex]]
0
[[Status]]
evaluated
[[AsyncEvaluationOrder]]
done
[[AsyncParentModules]]
« »
[[PendingAsyncDependencies]]
0
한편 C가 실행에 실패하고 B가 완료되기 전에 오류를 반환하는 실패 케이스를 생각해 봅시다. 이때 AsyncModuleExecutionRejected가
호출되어 C.[[Status]]가
evaluated로, C.[[EvaluationError]]가 오류로 설정됩니다. 그런 다음 이 오류는 모든
AsyncParentModules에 전파되어 각각에 대해 AsyncModuleExecutionRejected가
호출됩니다. 업데이트된 모듈들의 필드는 표
54에 나옵니다.
표 54: 모듈 C 오류 발생 후 모듈 필드
필드모듈
A
C
[[DFSAncestorIndex]]
0
0
[[Status]]
evaluated
evaluated
[[AsyncEvaluationOrder]]
done
done
[[AsyncParentModules]]
« »
« A »
[[PendingAsyncDependencies]]
1 (B)
0
[[EvaluationError]]
empty
C의 평가 오류
A는 C와 동일한 오류로 rejected됩니다. 이는 C가 A에 대해
AsyncModuleExecutionRejected를
C의 오류로 호출하기 때문입니다. A.[[Status]]는
evaluated로 설정됩니다. 이 시점에서 A.[[TopLevelCapability]]의 Promise(A.Evaluate()에서 반환된
Promise)는 reject됩니다. 업데이트된 모듈의 필드는 표 55에 나옵니다.
그 후 B는 오류 없이 실행을 마칩니다. 이 경우 AsyncModuleExecutionFulfilled가
다시 호출되고 B.[[Status]]가
evaluated로 설정됩니다. GatherAvailableAncestors가
B에 대해 호출됩니다. 그러나 A.[[CycleRoot]]는 평가 오류가
있는 A이므로 반환된 sortedExecList에 추가되지 않으며 AsyncModuleExecutionFulfilled는
추가 처리를 하지 않고 반환됩니다. 이후 B를 import하는 모듈은 C에서 사이클 루트 A에
설정된 평가 오류를 B.[[CycleRoot]].[[EvaluationError]]의 rejection으로 처리하게 됩니다. 업데이트된 모듈의 필드는
표 56에 나와 있습니다.
소스 텍스트
모듈 레코드는 ECMAScript 소스 텍스트(11)로 정의된 모듈에 대한 정보를 나타내는
데 사용되며, goal symbolModule을 사용하여 파싱됩니다. 그 필드에는 모듈이
import 및 export하는 이름에 대한 정제된 정보가 담겨 있으며, 구체적 메서드는 이 정보들을 사용하여 모듈을 linking 및 평가합니다.
ResolveExport는 import된 바인딩을 실제 정의 모듈과 로컬 바인딩 이름으로 해결하려 시도합니다. 정의 모듈은 이 메서드가 호출된
모듈 레코드일 수도 있고, 그 모듈이
import하는 다른 모듈일 수도 있습니다. resolveSet 파라미터는 미해결 순환 import/export 경로를 감지하기
위해 사용합니다. 특정 모듈 레코드와
exportName 쌍이 resolveSet에 이미 있으면 import 순환이 발견된 것입니다.
ResolveExport를 재귀적으로 호출하기 전에 module과 exportName 쌍을
resolveSet에 추가합니다.
정의 모듈이 발견되면 ResolvedBinding Record { [[Module]], [[BindingName]] }를
반환합니다. 이 레코드는 요청된 export의 해결된 바인딩을 나타내지만, 네임스페이스로 export되고 로컬 바인딩이 없는 경우에는 [[BindingName]]이 namespace로 설정됩니다.
정의가 없거나 요청이 순환임이 발견되면 null을 반환합니다. 요청이 모호함이 발견되면
ambiguous를 반환합니다.
resolution.[[Module]]과
starResolution.[[Module]]이 동일한 모듈
레코드가 아니면
ambiguous를 반환한다.
resolution.[[BindingName]]이
starResolution.[[BindingName]]과 다르고,
resolution.[[BindingName]] 또는
starResolution.[[BindingName]]이
namespace인 경우
ambiguous를 반환한다.
resolution.[[BindingName]]문자열이고,
starResolution.[[BindingName]]문자열이며,
두 값이 다르면 ambiguous를 반환한다.
AsyncBlockStart(capability,
module.[[ECMAScriptCode]],
moduleContext)를 수행한다.
unused를 반환한다.
16.2.1.8 합성 모듈 레코드
합성 모듈 레코드는 명세에 의해 정의된 모듈에 대한 정보를
나타내는 데 사용됩니다. export된 이름들은 생성 시에 정적으로 정의되며, 해당 값들은 SetSyntheticModuleExport를 사용하여
시간이 지나면서 변경될 수 있습니다. import나 의존성이 없습니다.
참고
합성 모듈 레코드는 JSON 모듈이나 CSS 모듈 등 다양한 타입의 모듈을 정의하는 데 사용할 수 있습니다.
표 43에 정의된 필드 외에도, 합성 모듈 레코드는
표 62에 나열된 추가 필드를 가집니다.
추상 연산 CreateDefaultExportSyntheticModule은 defaultExport(ECMAScript 언어 값)을 인자로 받아
합성 모듈 레코드를 반환합니다. 이 연산은
defaultExport를 default export로 갖는 합성 모듈 레코드를 생성합니다. 호출 시 다음
절차를 수행합니다:
추상 연산 SetSyntheticModuleExport는 module(합성 모듈 레코드),
exportName(문자열), exportValue(ECMAScript 언어 값)을 인자로 받아
unused를 반환합니다. 이 연산은 합성 모듈 레코드의 기존 export에 대한 값을
설정하거나 변경할 수 있습니다. 호출 시 다음 절차를 수행합니다:
Assert:
module.[[ExportNames]]에
exportName이 포함되어 있음을 확인한다.
실제 처리 과정은 호스트
정의이지만, 일반적으로 적절한 모듈 레코드를 로드하기 위한 필요한
모든 I/O 작업을 수행합니다. 여러 (referrer, moduleRequest.[[Specifier]], moduleRequest.[[Attributes]]) 삼중쌍이 동일한 모듈 레코드 인스턴스에 매핑될 수 있습니다. 실제 매핑
방식은 호스트
정의이지만, 일반적으로 매핑 과정에서 specifier에 대한 정규화 프로세스가 적용됩니다. 일반적인
정규화 과정에는 상대 경로 및 축약 경로 지정자의 확장이 포함될 수 있습니다.
참고 2
위 요구사항은 호스트가
type: "json"으로 import할 때 JSON 모듈을 지원해야 함을 의미하지만(그리고
HostLoadImportedModule이 정상적으로 완료될 경우), type: "json" 없이 import할 때 JSON
모듈을 지원하는 것을 금지하지는 않습니다.
16.2.1.11 FinishLoadingImportedModule ( referrer,
moduleRequest, payload, result )
HostGetSupportedImportAttributes 호스트 정의 추상 연산은 인자를 받지 않으며, 문자열의 List를 반환합니다.
호스트
환경이 지원하는 import attribute 키를 지정할 수 있게 합니다. 지원되는 키의 attribute만
호스트에 제공됩니다.
HostGetSupportedImportAttributes의 구현체는 아래 요구사항을 따라야 합니다:
HostGetSupportedImportAttributes의 기본 구현은 새로운 빈 List를 반환하는 것이다.
참고
지원되지 않는 attribute를 호스트에 전달하고 호스트가 원하는 것만 처리하게 하는 대신, 호스트가
지원하는 import attribute를 명시적으로 지정하도록 요구하는 목적은 서로 다른 호스트들 사이에서 지원되지 않는 attribute가 일관되게
처리되도록 하기 위함이다.
16.2.1.13 GetModuleNamespace ( module )
GetModuleNamespace 추상 연산은 module(모듈 레코드의 구체적 하위 클래스
인스턴스)을 인자로 받아 모듈 네임스페이스 객체(Module Namespace Object)를 반환합니다. 이 객체는 module의 export를
나타내며, 처음 요청 시 지연 생성되고, 이후 요청을 위해 module.[[Namespace]]에
저장됩니다. 호출 시 다음 절차를 수행합니다:
Assert:
module이 순환 모듈 레코드인 경우
module.[[Status]]는 new 또는
unlinked가 아님을 확인한다.
GetModuleNamespace는 예외를 throw하지 않습니다. 대신, 해결 불가능한 이름은 네임스페이스에서 단순히 제외됩니다. 실제 linking
오류는 나중에 발생하며, 단 ambiguous star export로만 구성되어 있고 명시적으로 요청되지 않을 경우에는 linking 오류가 나지 않을
수 있습니다.
Return a List whose
sole element is a new ExportEntry Record { [[ModuleRequest]]: null, [[ImportName]]: null, [[LocalName]]: localName, [[ExportName]]: "default" }.
Return a List whose
sole element is a new ExportEntry Record { [[ModuleRequest]]: null, [[ImportName]]: null, [[LocalName]]: localName, [[ExportName]]: "default" }.
Return a List whose
sole element is a new ExportEntry Record { [[ModuleRequest]]: module, [[ImportName]]: importName, [[LocalName]]: localName, [[ExportName]]: sourceName }.
Return a List whose
sole element is a new ExportEntry Record { [[ModuleRequest]]: module, [[ImportName]]: importName, [[LocalName]]: localName, [[ExportName]]: exportName }.
An implementation must report most errors at the time the relevant ECMAScript language construct is
evaluated. An early error is an error
that can be detected and reported prior to the evaluation of any construct in the Script containing the error. The presence of an
early error prevents
the evaluation of the construct. An implementation must report early errors in a Script as part of parsing that Script in ParseScript. Early errors in a Module are reported at the point when the Module would be evaluated and the Module is never initialized. Early errors in eval
code are reported at the time eval is called and prevent evaluation of the eval
code. All errors that are not early
errors are runtime errors.
An implementation must report as an early error any occurrence of a condition that is listed in a
“Static Semantics: Early Errors” subclause of this specification.
An implementation shall not treat other kinds of errors as early errors even if the compiler can prove
that a construct cannot execute without error under any circumstances. An implementation may issue an
early warning in such a case, but it should not report the error until the relevant construct is
actually executed.
An implementation shall report all errors as specified, except for the following:
Except as restricted in 17.1, a host or implementation may extend Script syntax, Module syntax, and regular expression pattern or flag
syntax. To permit this, all operations (such as calling eval, using a regular
expression literal, or using the Function or RegExp constructor) that are allowed to throw
SyntaxError are permitted to exhibit host-defined behaviour instead of throwing
SyntaxError when they encounter a host-defined extension to the script
syntax or regular expression pattern or flag syntax.
Except as restricted in 17.1, a host or implementation may provide additional
types, values, objects, properties, and functions beyond those described in this specification. This
may cause constructs (such as looking up a variable in the global scope) to have host-defined
behaviour instead of throwing an error (such as ReferenceError).
17.1 Forbidden Extensions
An implementation must not extend this specification in the following ways:
If an implementation extends any function object with an own property named
"caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a
strict
function object. If it is an accessor property, the function
that is the value of the property's [[Get]] attribute must never return
a strict
function when called.
Neither mapped nor unmapped arguments objects may be created with an own property named
"caller".
The behaviour of built-in methods which are specified in ECMA-402, such as those named
toLocaleString, must not be extended except as specified in ECMA-402.
The RegExp pattern grammars in 22.2.1 and B.1.2 must not be extended to
recognize any of the source characters A-Z or a-z as IdentityEscape[+UnicodeMode]
when the [UnicodeMode] grammar parameter is present.
The Syntactic Grammar must not be extended in any manner that allows the token : to
immediately follow source text that is matched by the BindingIdentifier nonterminal symbol.
There are certain built-in objects available whenever an ECMAScript Script or Module begins execution. One, the global object,
is part of the global environment of the executing program. Others are accessible as initial properties
of the global
object or indirectly as properties of accessible built-in objects.
Unless specified otherwise, a built-in object that is callable as a function is a built-in function object
with the characteristics described in 10.3. Unless specified otherwise, the [[Extensible]] internal slot of a built-in object initially has the value
true. Every built-in function object has a [[Realm]]
internal slot whose value is the Realm Record of the realm for which the object was initially created.
Many built-in objects are functions: they can be invoked with arguments. Some of them furthermore are
constructors: they
are functions intended for use with the new operator. For each built-in function, this
specification describes the arguments required by that function and the properties of that function object.
For each built-in constructor, this specification furthermore describes
properties of the prototype object of that constructor and properties of specific object instances
returned by a new expression that invokes that constructor.
Unless otherwise specified in the description of a particular function, if a built-in function or
constructor is given
fewer arguments than the function is specified to require, the function or constructor shall behave exactly as if it had
been given sufficient additional arguments, each such argument being the undefined
value. Such missing arguments are considered to be “not present” and may be identified in that manner by
specification algorithms. In the description of a particular function, the terms
“this value” and “NewTarget” have the meanings given in 10.3.
Unless otherwise specified in the description of a particular function, if a built-in function or
constructor described
is given more arguments than the function is specified to allow, the extra arguments are evaluated by
the call and then ignored by the function. However, an implementation may define implementation specific
behaviour relating to such arguments as long as the behaviour is not the throwing of a
TypeError exception that is predicated simply on the presence of an extra argument.
Note 1
Implementations that add additional capabilities to the set of built-in functions are encouraged
to do so by adding new functions rather than adding new parameters to existing functions.
Unless otherwise specified every built-in function and every built-in constructor has the Function prototype
object, which is the initial value of the expression
Function.prototype (20.2.3), as
the value of its [[Prototype]] internal slot.
Unless otherwise specified every built-in prototype object has the Object prototype object,
which is the initial value of the expression Object.prototype (20.1.3), as the value of
its [[Prototype]] internal slot, except the Object prototype object
itself.
If this specification defines a built-in constructor's behaviour via algorithm steps, then that is its
behaviour for the purposes of both [[Call]] and [[Construct]]. If such an algorithm needs to distinguish the two cases, it
checks whether NewTarget is undefined, which indicates a [[Call]] invocation.
Built-in function
objects that are not identified as constructors do not implement the [[Construct]] internal method unless otherwise specified in the description of a
particular function.
Built-in function
objects that are not constructors do not have a "prototype"
property unless otherwise specified in the description of a particular function.
Each built-in function defined in this specification is created by calling the CreateBuiltinFunction abstract operation
(10.3.4). The values of the length
and name parameters are the initial values of the "length" and
"name" properties as discussed below. The values of the prefix parameter
are similarly discussed below.
Every built-in function
object, including constructors, has a "length" property
whose value is a non-negative integral Number. Unless otherwise specified, this value
is the number of required parameters shown in the subclause heading for the function description.
Optional parameters and rest parameters are not included in the parameter count.
Note 2
For example, the function object that is the initial value of the
"map" property of the Array prototype
object is described under the subclause heading «Array.prototype.map
(callback [ , thisArg])» which shows the two named arguments callback and thisArg, the latter
being optional; therefore the value of the "length" property of that
function
object is 1𝔽.
Unless otherwise specified, the "length" property of a built-in function object has
the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.
Every built-in function
object, including constructors, has a "name" property whose
value is a String. Unless otherwise
specified, this value is the name that is given to the function in this specification. Functions that
are identified as anonymous functions use the empty String as the value of the "name"
property. For functions that are specified as properties of objects, the name value is the property name string
used to access the function. Functions that are specified as get or set accessor functions of built-in
properties have "get" or "set" (respectively) passed to the
prefix parameter when calling CreateBuiltinFunction.
The value of the "name" property is explicitly specified for each built-in functions
whose property keyis a Symbol value. If such an
explicitly specified value starts with the prefix "get " or "set "
and the function for which it is specified is a get or set accessor function of a built-in property, the
value without the prefix is passed to the name parameter, and the value
"get" or "set" (respectively) is passed to the prefix
parameter when calling CreateBuiltinFunction.
Unless otherwise specified, the "name" property of a built-in function object has
the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.
Every other data
property described in clauses 19 through 28 and in Annex
B.2 has the attributes { [[Writable]]: true, [[Enumerable]]:
false, [[Configurable]]: true } unless
otherwise specified.
Every accessor
property described in clauses 19 through 28 and in Annex
B.2 has the attributes { [[Enumerable]]: false, [[Configurable]]: true } unless otherwise specified. If only
a get accessor function is described, the set accessor function is the default value,
undefined. If only a set accessor is described the get accessor is the default value,
undefined.
does not have a [[Construct]] internal method; it cannot be used as a
constructor with
the new operator.
does not have a [[Call]] internal method; it cannot be invoked as a
function.
has a [[Prototype]] internal slot whose value is host-defined.
may have host-defined properties in addition to the properties
defined in this specification. This may include a property whose value is the global object itself.
19.1 Value Properties of the Global Object
19.1.1 globalThis
The initial value of the "globalThis" property of the global
object in a Realm Recordrealm is
realm.[[GlobalEnv]].[[GlobalThisValue]].
This property has the attributes { [[Writable]]:
true, [[Enumerable]]: false, [[Configurable]]: true }.
19.1.2 Infinity
The value of Infinity is +∞𝔽 (see 6.1.6.1). This property
has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
19.1.3 NaN
The value of NaN is NaN (see 6.1.6.1). This property
has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
19.1.4 undefined
The value of undefined is undefined (see 6.1.1). This
property has the attributes { [[Writable]]: false,
[[Enumerable]]: false, [[Configurable]]: false }.
NOTE: If direct is true, runningContext
will be the execution context that
performed the direct
eval. If direct is false,
runningContext will be the execution
context for the invocation of the eval function.
The eval code cannot instantiate variable or function bindings in the variable
environment of the calling context that invoked the eval if either the code of the
calling context or the eval code is strict mode code.
Instead such bindings are instantiated in a new VariableEnvironment that is only
accessible to the eval code. Bindings introduced by let,
const, or class declarations are always instantiated in a
new LexicalEnvironment.
19.2.1.2 HostEnsureCanCompileStrings ( calleeRealm,
parameterStrings, bodyString, direct )
The host-defined abstract operation
HostEnsureCanCompileStrings takes arguments calleeRealm (a Realm
Record), parameterStrings (a List of Strings),
bodyString (a String), and direct (a Boolean) and returns either a
normal completion
containingunused or a throw completion. It
allows host
environments to block certain ECMAScript functions which allow
developers to interpret and evaluate strings as ECMAScript code.
parameterStrings represents the strings that, when using one of the function
constructors, will be concatenated together to
build the parameters list. bodyString represents the function body or the string
passed to an eval call.
direct signifies whether the evaluation is a direct eval.
The default implementation of HostEnsureCanCompileStrings is to return NormalCompletion(unused).
Let trimmedPrefix be the longest prefix of trimmed that satisfies
the syntax of a StrDecimalLiteral, which might be
trimmed itself. If there is no such prefix, return NaN.
This function may interpret only a leading portion of string as a Number
value; it ignores any code units that cannot be interpreted as part of the notation of a
decimal literal, and no indication is given that any such code units were ignored.
19.2.5 parseInt ( string, radix )
This function produces an integral Number dictated by interpretation of the
contents of string according to the specified radix. Leading white space
in string is ignored. If radix coerces to 0 (such as when it is
undefined), it is assumed to be 10 except when the number representation
begins with "0x" or "0X", in which case it is assumed to
be 16. If radix is 16, the number representation may optionally begin with
"0x" or "0X".
If S is not empty and the first code unit of S is the code unit
0x002D (HYPHEN-MINUS), set sign to -1.
If S is not empty and the first code unit of S is either the code
unit 0x002B (PLUS SIGN) or the code unit 0x002D (HYPHEN-MINUS), set S to the
substring
of S from index 1.
If S contains a code unit that is not a radix-R digit, let
end be the index within S of the first such code unit; otherwise
let end be the length of S.
Let mathInt be the integer value that is represented by Z
in radix-R notation, using the letters A through Z and a
through z for digits with values 10 through 35. (However, if R = 10
and Z contains more than 20 significant digits, every significant digit after
the 20th may be replaced by a 0 digit, at the option of the implementation; and if
R is not one of 2, 4, 8, 10, 16, or 32, then mathInt may be an
implementation-approximatedinteger
representing the integer value denoted by Z in
radix-R notation.)
This function may interpret only a leading portion of string as an integer value; it
ignores any code units that cannot be interpreted as part of the notation of an
integer, and
no indication is given that any such code units were ignored.
19.2.6 URI Handling Functions
Uniform Resource Identifiers, or URIs, are Strings that identify resources (e.g. web pages or
files) and transport protocols by which to access them (e.g. HTTP or FTP) on the Internet. The
ECMAScript language itself does not provide any support for using URIs except for functions that
encode and decode URIs as described in this section. encodeURI and
decodeURI are intended to work with complete URIs; they assume that any reserved
characters are intended to have special meaning (e.g., as delimiters) and so are not encoded.
encodeURIComponent and decodeURIComponent are intended to work with
the individual components of a URI; they assume that any reserved characters represent text and
must be encoded to avoid special meaning when the component is part of a complete URI.
Note 1
The set of reserved characters is based upon RFC 2396 and does not reflect changes
introduced by the more recent RFC 3986.
Note 2
Many implementations of ECMAScript provide additional functions and methods that
manipulate web pages; these functions are beyond the scope of this standard.
19.2.6.1 decodeURI ( encodedURI )
This function computes a new version of a URI in which each escape sequence and UTF-8
encoding of the sort that might be introduced by the encodeURI function is
replaced with the UTF-16 encoding of the code point that it represents. Escape sequences
that could not have been introduced by encodeURI are not replaced.
This function computes a new version of a URI in which each escape sequence and UTF-8
encoding of the sort that might be introduced by the encodeURIComponent
function is replaced with the UTF-16 encoding of the code point that it represents.
It is the %decodeURIComponent% intrinsic object.
It performs the following steps when called:
Let componentString be ? ToString(encodedURIComponent).
This function computes a new version of a UTF-16 encoded (6.1.4) URI in which
each instance of certain code points is replaced by one, two, three, or four escape
sequences representing the UTF-8 encoding of the code point.
This function computes a new version of a UTF-16 encoded (6.1.4) URI in which
each instance of certain code points is replaced by one, two, three, or four escape
sequences representing the UTF-8 encoding of the code point.
The abstract operation Encode takes arguments string (a String) and
extraUnescaped (a String) and returns either a normal completion
containing a String or a throw completion. It
performs URI encoding and escaping, interpreting string as a sequence of UTF-16
encoded code points as described in 6.1.4. If a
character is identified as unreserved in RFC 2396 or appears in extraUnescaped,
it is not escaped. It performs the following steps when called:
Because percent-encoding is used to represent individual octets, a single code point
may be expressed as multiple consecutive escape sequences (one for each of its 8-bit
UTF-8 code units).
19.2.6.6 Decode ( string,
preserveEscapeSet )
The abstract operation Decode takes arguments string (a String) and
preserveEscapeSet (a String) and returns either a normal completion
containing a String or a throw completion. It
performs URI unescaping and decoding, preserving any escape sequences that correspond to
Basic Latin characters in preserveEscapeSet. It performs the following steps when
called:
Let len be the length of string.
Let R be the empty String.
Let k be 0.
Repeat, while k < len,
Let C be the code unit at index k within
string.
Let S be C.
If C is the code unit 0x0025 (PERCENT SIGN), then
If k + 3 > len, throw a
URIError exception.
Let escape be the substring of
string from k to k + 3.
RFC 3629 prohibits the decoding of invalid UTF-8 octet sequences. For example, the
invalid sequence 0xC0 0x80 must not decode into the code unit 0x0000.
Implementations of the Decode algorithm are required to throw a
URIError when encountering such invalid sequences.
19.2.6.7 ParseHexOctet ( string, position
)
The abstract operation ParseHexOctet takes arguments string (a String) and
position (a non-negative integer) and returns either a non-negative integer or a non-empty
List of
SyntaxError objects. It parses a sequence of two hexadecimal characters
at the specified position in string into an unsigned 8-bit integer. It performs
the following steps when called:
callback should be a function that accepts two arguments.
groupBy calls callback once for each element in
items, in ascending order, and constructs a new object. Each value
returned by callback is coerced to a property key. For each
such property
key, the result object has a property whose key is that
property
key and whose value is an array containing all the elements
for which the callback return value coerced to that key.
callback is called with two arguments: the value of the element and the
index of the element.
The return value of groupBy is an object that does not inherit from
%Object.prototype%.
This function performs the following steps when called:
Let groups be ? GroupBy(items,
callback, property).
The ordering of steps 1 and
2 is chosen to ensure
that any exception that would have been thrown by step 1 in previous
editions of this specification will continue to be thrown even if the
this value is undefined or
null.
20.1.3.3 Object.prototype.isPrototypeOf ( V )
This method performs the following steps when called:
The ordering of steps 1 and
2 preserves the behaviour
specified by previous editions of this specification for the case where V
is not an object and the this value is
undefined or null.
20.1.3.4 Object.prototype.propertyIsEnumerable ( V )
This method performs the following steps when called:
This method does not consider objects in the prototype chain.
Note 2
The ordering of steps 1 and
2 is chosen to
ensure that any exception that would have been thrown by step 1 in previous
editions of this specification will continue to be thrown even if the
this value is undefined or
null.
The optional parameters to this method are not used but are intended to correspond to the
parameter pattern used by ECMA-402 toLocaleString methods. Implementations that
do not include ECMA-402 support must not use those parameter positions for other purposes.
Note 1
This method provides a generic toLocaleString implementation for objects
that have no locale-sensitive toString behaviour. Array,
Number, Date, and %TypedArray%
provide their own locale-sensitive toLocaleString methods.
Note 2
ECMA-402 intentionally does not provide an alternative to this default
implementation.
20.1.3.6 Object.prototype.toString ( )
This method performs the following steps when called:
If the this value is undefined, return
"[object Undefined]".
If the this value is null, return
"[object Null]".
Historically, this method was occasionally used to access the String value of the
[[Class]] internal slot that was used in previous editions
of this specification as a nominal type tag for various built-in objects. The above
definition of toString preserves compatibility for legacy code that
uses toString as a test for those specific kinds of built-in objects.
It does not provide a reliable type testing mechanism for other kinds of built-in or
program defined objects. In addition, programs can use %Symbol.toStringTag% in ways
that will invalidate the reliability of such legacy type tests.
20.1.3.7 Object.prototype.valueOf ( )
This method performs the following steps when called:
Object.prototype.__proto__ is an accessor property with
attributes { [[Enumerable]]: false, [[Configurable]]: true }. The [[Get]] and [[Set]] attributes are defined
as follows:
20.1.3.8.1 get Object.prototype.__proto__
The value of the [[Get]] attribute is a built-in function that
requires no arguments. It performs the following steps when called:
is the initial value of the "Function" property of the global
object.
creates and initializes a new function object when called as a function
rather than as a constructor. Thus the function call
Function(…) is equivalent to the object creation expression
new Function(…) with the same arguments.
may be used as the value of an extends clause of a class definition. Subclass
constructors that intend to inherit the specified
Function behaviour must include a super call to the Function constructor to
create and initialize a subclass instance with the internal slots necessary for built-in
function behaviour. All ECMAScript syntactic forms for defining function
objects create instances of Function. There is no syntactic means to
create instances of Function subclasses except for the built-in GeneratorFunction,
AsyncFunction, and AsyncGeneratorFunction subclasses.
20.2.1.1 Function ( ...parameterArgs,
bodyArg )
The last argument (if any) specifies the body (executable code) of a function; any preceding
arguments specify formal parameters.
This function performs the following steps when called:
It is permissible but not necessary to have one argument for each formal parameter to
be specified. For example, all three of the following expressions produce the same
result:
The abstract operation CreateDynamicFunction takes arguments constructor (a
constructor), newTarget (a
constructor or undefined),
kind (normal, generator,
async, or async-generator),
parameterArgs (a List
of ECMAScript language
values), and bodyArg (an ECMAScript language value)
and returns either a normal completion
containing an ECMAScript function object or a
throw
completion. constructor is the constructor
function that is performing this action. newTarget is the constructor
that new was initially applied to. parameterArgs and
bodyArg reflect the argument values that were passed to
constructor. It performs the following steps when called:
If newTarget is undefined, set
newTarget to constructor.
If body is a List of
errors, throw a SyntaxError exception.
NOTE: The parameters and body are parsed separately to ensure that each is valid
alone. For example, new Function("/*", "*/ ) {") does not evaluate
to a function.
NOTE: If this step is reached, sourceText must have the syntax of
exprSym (although the reverse implication does not hold). The purpose
of the next two steps is to enforce any Early Error rules which apply to
exprSym directly.
NOTE: Functions whose kind is async are not
constructable and do not have a [[Construct]] internal
method or a "prototype" property.
Return F.
Note
CreateDynamicFunction defines a "prototype" property on any
function it creates whose kind is not async to
provide for the possibility that the function will be used as a constructor.
has a "name" property whose value is the empty String.
Note
The Function prototype object is specified to be a function object to ensure
compatibility with ECMAScript code that was created prior to the ECMAScript 2015
specification.
The thisArg value is passed without modification as the
this value. This is a change from Edition 3, where an
undefined or nullthisArg is
replaced with the global object and ToObject
is applied to all other values and that result is passed as the
this value. Even though the thisArg is passed without
modification, non-strict functions still
perform these transformations upon entry to the function.
Note 2
If func is either an arrow function or a bound function exotic
object, then the thisArg will be ignored by the
function [[Call]] in step 6.
Function
objects created using Function.prototype.bind
are exotic
objects. They also do not have a
"prototype" property.
Note 2
If Target is either an arrow function or a bound function exotic
object, then the thisArg passed to this method
will not be used by subsequent calls to F.
The thisArg value is passed without modification as the
this value. This is a change from Edition 3, where an
undefined or nullthisArg is
replaced with the global object and ToObject
is applied to all other values and that result is passed as the
this value. Even though the thisArg is passed without
modification, non-strict functions still
perform these transformations upon entry to the function.
Note 2
If func is either an arrow function or a bound function exotic
object, then the thisArg will be ignored by the
function [[Call]] in step 4.
20.2.3.4 Function.prototype.constructor
The initial value of Function.prototype.constructor is %Function%.
20.2.3.5 Function.prototype.toString ( )
This method performs the following steps when called:
Let func be the this value.
If funcis an Object, func has a
[[SourceText]] internal slot, func.[[SourceText]] is a sequence of Unicode code points, and
HostHasSourceTextAvailable(func)
is true, then
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
Note
This is the default implementation of %Symbol.hasInstance% that most
functions inherit. %Symbol.hasInstance% is called by the
instanceof operator to determine whether a value is an instance of a
specific constructor. An expression such as
v instanceof F
evaluates as
F[%Symbol.hasInstance%](v)
A constructor function can control which
objects are recognized as its instances by instanceof by exposing a
different %Symbol.hasInstance% method on the function.
This property is non-writable and non-configurable to prevent tampering that could be used to
globally expose the target function of a bound function.
The value of the "name" property of this method is
"[Symbol.hasInstance]".
20.2.4 Function Instances
Every Function instance is an ECMAScript function object and has the internal slots listed
in Table 30.
Function
objects created using the Function.prototype.bind method
(20.2.3.2) have the internal slots
listed in Table
31.
Function instances have the following properties:
20.2.4.1 length
The value of the "length" property is an integral Number that indicates
the typical number of arguments expected by the function. However, the language permits the
function to be invoked with some other number of arguments. The behaviour of a function when
invoked on a number of arguments other than the number specified by its
"length" property depends on the function. This property has the
attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.
20.2.4.2 name
The value of the "name" property is a String that is
descriptive of the function. The name has no semantic significance but is typically a
variable or property
name that is used to refer to the function at its point of definition
in ECMAScript
source text. This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: true }.
Anonymous functions objects that do not have a contextual name associated with them by this
specification use the empty String as the value of the "name" property.
20.2.4.3 prototype
Function instances that can be used as a constructor have a "prototype"
property. Whenever such a Function instance is created another ordinary
object is also created and is the initial value of the function's
"prototype" property. Unless otherwise specified, the value of the
"prototype" property is used to initialize the [[Prototype]] internal slot of the object created when that function
is invoked as a constructor.
This property has the attributes { [[Writable]]:
true, [[Enumerable]]: false,
[[Configurable]]: false }.
The host-defined abstract operation
HostHasSourceTextAvailable takes argument func (a function object) and returns a
Boolean. It allows host environments to prevent the source text
from being provided for func.
An implementation of HostHasSourceTextAvailable must conform to the following requirements:
It must be deterministic with respect to its parameters. Each time it is called with a
specific func as its argument, it must return the same result.
The default implementation of HostHasSourceTextAvailable is to return true.
is the initial value of the "Boolean" property of the global
object.
creates and initializes a new Boolean object when called as a constructor.
performs a type conversion when called as a function rather than as a constructor.
may be used as the value of an extends clause of a class definition. Subclass
constructors that intend to inherit the specified
Boolean behaviour must include a super call to the Boolean constructor to
create and initialize the subclass instance with a [[BooleanData]]
internal slot.
20.3.1.1 Boolean ( value )
This function performs the following steps when called:
Boolean instances are ordinary objects that inherit properties from the
Boolean prototype
object. Boolean instances have a [[BooleanData]]
internal slot. The [[BooleanData]] internal slot is the Boolean value
represented by this Boolean object.
The GlobalSymbolRegistry List is an append-only List that is globally
available. It is shared by all realms. Prior to the evaluation of any ECMAScript code,
it is initialized as a new empty List.
Elements of the GlobalSymbolRegistry List are Records with the
structure defined in Table
63.
The initial value of Symbol.prototype.constructor is %Symbol%.
20.4.3.2 get Symbol.prototype.description
Symbol.prototype.description is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
The initial value of the %Symbol.toStringTag% property is the
String value "Symbol".
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: true }.
20.4.4 Properties of Symbol Instances
Symbol instances are ordinary objects that inherit properties from the
Symbol prototype
object. Symbol instances have a [[SymbolData]]
internal slot. The [[SymbolData]] internal slot is the Symbol value
represented by this Symbol object.
20.4.5 Abstract Operations for Symbols
20.4.5.1 KeyForSymbol ( sym )
The abstract operation KeyForSymbol takes argument sym (a Symbol) and returns a
String or undefined. If sym is in the GlobalSymbolRegistry
List, the String used to register sym will be returned. It
performs the following steps when called:
Instances of Error objects are thrown as exceptions when runtime errors occur. The Error objects may
also serve as base objects for user-defined exception classes.
When an ECMAScript implementation detects a runtime error, it throws a new instance of one of the
NativeError objects defined in 20.5.5 or a new instance
of the AggregateError object defined in 20.5.7.
is the initial value of the "Error" property of the global
object.
creates and initializes a new Error object when called as a function rather than as a
constructor. Thus the function call
Error(…) is equivalent to the object creation expression
new Error(…) with the same arguments.
may be used as the value of an extends clause of a class definition. Subclass
constructors that intend to inherit the specified
Error behaviour must include a super call to the Error constructor to
create and initialize subclass instances with an [[ErrorData]]
internal slot.
20.5.1.1 Error ( message [ , options ] )
This function performs the following steps when called:
If NewTarget is undefined, let newTarget be the
active function object; else
let newTarget be NewTarget.
If msg is undefined, set msg to the empty
String; otherwise set msg to ? ToString(msg).
If name is the empty String, return msg.
If msg is the empty String, return name.
Return the string-concatenation of
name, the code unit 0x003A (COLON), the code unit 0x0020 (SPACE), and
msg.
20.5.4 Properties of Error Instances
Error instances are ordinary objects that inherit properties from the
Error prototype
object and have an [[ErrorData]] internal slot
whose value is undefined. The only specified use of [[ErrorData]] is to identify Error, AggregateError, and
NativeError instances as Error objects within Object.prototype.toString
and Error.isError.
20.5.5 Native Error Types Used in This Standard
A new instance of one of the NativeError objects below or of the AggregateError object
is thrown when a runtime error is detected. All NativeError objects share the same
structure, as described in 20.5.6.
Indicates that one of the global URI handling functions was used in a way that is
incompatible with its definition.
20.5.6NativeError Object Structure
Each of these objects has the structure described below, differing only in the name used as the
constructor
name and in the "name" property of the prototype object.
For each error object, references to NativeError in the definition should be replaced
with the appropriate error object name from 20.5.5.
creates and initializes a new NativeError object when called as a function
rather than as a constructor. A call of the object as a
function is equivalent to calling it as a constructor with the same
arguments. Thus the function call NativeError(…) is equivalent
to the object creation expression new NativeError(…) with the
same arguments.
may be used as the value of an extends clause of a class definition.
Subclass constructors that intend to inherit the
specified NativeError behaviour must include a super call to the
NativeErrorconstructor to create and initialize subclass
instances with an [[ErrorData]] internal slot.
20.5.6.1.1NativeError ( message [ ,
options ] )
Each NativeError function performs the following steps when called:
If NewTarget is undefined, let newTarget be the
active function object;
else let newTarget be NewTarget.
The actual value of the string passed in step 2 is
either "%EvalError.prototype%",
"%RangeError.prototype%",
"%ReferenceError.prototype%",
"%SyntaxError.prototype%",
"%TypeError.prototype%", or "%URIError.prototype%"
corresponding to which NativeErrorconstructor is being defined.
20.5.6.2 Properties of the NativeError Constructors
The initial value of the "constructor" property of the prototype for a
given NativeErrorconstructor is the constructor
itself.
20.5.6.3.2NativeError.prototype.message
The initial value of the "message" property of the prototype for a
given NativeErrorconstructor is the empty String.
20.5.6.3.3NativeError.prototype.name
The initial value of the "name" property of the prototype for a given
NativeErrorconstructor is the String value consisting of
the name of the constructor (the name used instead of
NativeError).
20.5.6.4 Properties of NativeError Instances
NativeError instances are ordinary objects that inherit properties from
their NativeError prototype object and have an [[ErrorData]] internal slot whose value is
undefined. The only specified use of [[ErrorData]] is by Object.prototype.toString
(20.1.3.6) and
Error.isError (20.5.2.1) to identify Error,
AggregateError, or NativeError instances.
is the initial value of the "AggregateError" property of the
global
object.
creates and initializes a new AggregateError object when called as a function rather
than as a constructor. Thus the function call
AggregateError(…) is equivalent to the object creation expression
new AggregateError(…) with the same arguments.
may be used as the value of an extends clause of a class definition.
Subclass constructors that intend to inherit the
specified AggregateError behaviour must include a super call to the
AggregateError constructor to create and initialize subclass
instances with an [[ErrorData]] internal slot.
The initial value of AggregateError.prototype.constructor is %AggregateError%.
20.5.7.3.2 AggregateError.prototype.message
The initial value of AggregateError.prototype.message is the empty String.
20.5.7.3.3 AggregateError.prototype.name
The initial value of AggregateError.prototype.name is
"AggregateError".
20.5.7.4 Properties of AggregateError Instances
AggregateError instances are ordinary objects that inherit properties from
their AggregateError
prototype object and have an [[ErrorData]]
internal slot whose value is undefined. The only specified use of [[ErrorData]] is by Object.prototype.toString
(20.1.3.6) and
Error.isError (20.5.2.1) to identify Error,
AggregateError, or NativeError instances.
20.5.8 Abstract Operations for Error Objects
20.5.8.1 InstallErrorCause ( O, options )
The abstract operation InstallErrorCause takes arguments O (an Object) and
options (an ECMAScript language value) and
returns either a normal completion
containingunused or a throw completion. It
is used to create a "cause" property on O when a
"cause" property is present on options. It performs the
following steps when called:
is the initial value of the "Number" property of the global
object.
creates and initializes a new Number object when called as a constructor.
performs a type conversion when called as a function rather than as a constructor.
may be used as the value of an extends clause of a class definition. Subclass
constructors that intend to inherit the specified
Number behaviour must include a super call to the Number constructor to
create and initialize the subclass instance with a [[NumberData]]
internal slot.
21.1.1.1 Number ( value )
This function performs the following steps when called:
The value of Number.EPSILON is the Number value for the magnitude
of the difference between 1 and the smallest value greater than 1 that is representable as a
Number value, which is approximately 2.2204460492503130808472633361816 × 10-16.
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
21.1.2.2 Number.isFinite ( number )
This function performs the following steps when called:
This function differs from the global isNaN function (19.2.3) in that it does not convert
its argument to a Number before determining whether it is NaN.
Due to rounding behaviour necessitated by precision limitations of IEEE
754-2019, the Number value for every
integer
greater than Number.MAX_SAFE_INTEGER is shared with at least one other
integer.
Such large-magnitude integers are therefore not safe,
and are not guaranteed to be exactly representable as Number values or even to be
distinguishable from each other. For example, both 9007199254740992 and
9007199254740993 evaluate to the Number value
9007199254740992𝔽.
The value of Number.MAX_SAFE_INTEGER is
9007199254740991𝔽 (𝔽(253 - 1)).
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
21.1.2.7 Number.MAX_VALUE
The value of Number.MAX_VALUE is the largest positive finite value of the Number type, which
is approximately 1.7976931348623157 × 10308.
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
21.1.2.8 Number.MIN_SAFE_INTEGER
Note
Due to rounding behaviour necessitated by precision limitations of IEEE
754-2019, the Number value for every
integer
less than Number.MIN_SAFE_INTEGER is shared with at least one other
integer.
Such large-magnitude integers are therefore not safe,
and are not guaranteed to be exactly representable as Number values or even to be
distinguishable from each other. For example, both -9007199254740992
and -9007199254740993 evaluate to the Number value
-9007199254740992𝔽.
The value of Number.MIN_SAFE_INTEGER is
-9007199254740991𝔽 (𝔽(-(253 - 1))).
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
21.1.2.9 Number.MIN_VALUE
The value of Number.MIN_VALUE is the smallest positive value of the Number type, which
is approximately 5 × 10-324.
In the IEEE
754-2019 double precision binary representation, the smallest
possible value is a denormalized number. If an implementation does not support denormalized
values, the value of Number.MIN_VALUE must be the smallest non-zero positive
value that can actually be represented by the implementation.
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
21.1.2.10 Number.NaN
The value of Number.NaN is NaN.
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
21.1.2.11 Number.NEGATIVE_INFINITY
The value of Number.NEGATIVE_INFINITY is -∞𝔽.
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
21.1.2.12 Number.parseFloat ( string )
The initial value of the "parseFloat" property is %parseFloat%.
21.1.2.13 Number.parseInt ( string, radix
)
The initial value of the "parseInt" property is %parseInt%.
21.1.2.14 Number.POSITIVE_INFINITY
The value of Number.POSITIVE_INFINITY is +∞𝔽.
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
Unless explicitly stated otherwise, the methods of the Number prototype object defined below are
not generic and the this value passed to them must be either a Number value
or an object that has a [[NumberData]] internal slot that has been
initialized to a Number value.
The phrase “this Number value” within the specification of a method refers to the result returned
by calling the abstract operation ThisNumberValue with the
this value of the method invocation passed as the argument.
21.1.3.1 Number.prototype.constructor
The initial value of Number.prototype.constructor is %Number%.
This method returns a String containing this Number value represented in decimal exponential
notation with one digit before the significand's decimal point and fractionDigits
digits after the significand's decimal point. If fractionDigits is
undefined, it includes as many significand digits as necessary to
uniquely specify the Number (just like in ToString except that in this case the Number is
always output in exponential notation).
Let m be the String value consisting of f + 1
occurrences of the code unit 0x0030 (DIGIT ZERO).
Let e be 0.
Else,
If fractionDigits is not undefined, then
Let e and n be integers such
that 10f ≤ n <
10f + 1 and for which n ×
10e - f - x is as close
to zero as possible. If there are two such sets of e and
n, pick the e and n for which
n × 10e - f is larger.
Else,
Let
e, n, and ff be integers such that
ff ≥ 0, 10ff ≤ n <
10ff + 1, 𝔽(n ×
10e - ff) is 𝔽(x),
and ff is as small as possible. Note that the decimal
representation of n has ff + 1 digits,
n is not divisible by 10, and the least significant digit
of n is not necessarily uniquely determined by these
criteria.
Set f to ff.
Let m be the String value consisting of the digits of the decimal
representation of n (in order, with no leading zeroes).
For implementations that provide more accurate conversions than required by the rules
above, it is recommended that the following alternative version of step 10.b.i
be used as a guideline:
Let e, n, and f be integers such that f ≥ 0,
10f ≤ n < 10f + 1,
𝔽(n × 10e -
f) is 𝔽(x), and f is as
small as possible. If there are multiple possibilities for n,
choose the value of n for which 𝔽(n ×
10e - f) is closest in value to 𝔽(x).
If there are two such possible values of n, choose the one that
is even.
This method returns a String containing this Number value represented in decimal
fixed-point notation with fractionDigits digits after the decimal point.
If fractionDigits is undefined, 0 is assumed.
Let n be an integer for which n /
10f - x is as close to zero as possible. If
there are two such n, pick the larger n.
If n = 0, let m be "0"; otherwise
let m be the String value consisting of the digits of the decimal
representation of n (in order, with no leading zeroes).
If f ≠ 0, then
Let k be the length of m.
If k ≤ f, then
Let z be the String value consisting of
f + 1 - k occurrences of the code unit
0x0030 (DIGIT ZERO).
The output of toFixed may be more precise than toString for
some values because toString only prints enough significant digits to distinguish
the number from adjacent Number values. For example,
(1000000000000000128).toString() returns
"1000000000000000100", while (1000000000000000128).toFixed(0) returns
"1000000000000000128".
An ECMAScript implementation that includes the ECMA-402 Internationalization API must
implement this method as specified in the ECMA-402 specification. If an ECMAScript
implementation does not include the ECMA-402 API the following specification of this method
is used:
This method produces a String value that represents this Number value formatted according to
the conventions of the host environment's current locale. This
method is implementation-defined, and it is
permissible, but not encouraged, for it to return the same thing as toString.
The meanings of the optional parameters to this method are defined in the ECMA-402
specification; implementations that do not include ECMA-402 support must not use those
parameter positions for anything else.
This method returns a String containing this Number value represented either in decimal
exponential notation with one digit before the significand's decimal point and precision - 1 digits after the significand's decimal
point or in decimal fixed notation with precision significant digits. If
precision is undefined, it calls ToString instead.
Let m be the String value consisting of p occurrences
of the code unit 0x0030 (DIGIT ZERO).
Let e be 0.
Else,
Let e and n be integers such that
10p - 1 ≤ n < 10p
and for which n × 10e - p + 1 -
x is as close to zero as possible. If there are two such sets of
e and n, pick the e and n for
which n × 10e - p + 1 is larger.
Let m be the String value consisting of the digits of the decimal
representation of n (in order, with no leading zeroes).
Set m to the string-concatenation of
the first e + 1 code units of m, the code unit 0x002E
(FULL STOP), and the remaining p - (e + 1) code units
of m.
Else,
Set m to the string-concatenation of
the code unit 0x0030 (DIGIT ZERO), the code unit 0x002E (FULL STOP),
-(e + 1) occurrences of the code unit 0x0030 (DIGIT ZERO), and
the String m.
The optional radix should be an integral Number value
in the inclusive interval from
2𝔽 to 36𝔽. If
radix is undefined then
10𝔽 is used as the value of radix.
This method performs the following steps when called:
This method is not generic; it throws a TypeError exception if its
this value is not a
Number or a Number object. Therefore, it cannot be transferred to
other kinds of objects for use as a method.
Number instances are ordinary objects that inherit properties from the
Number prototype
object. Number instances also have a [[NumberData]] internal slot. The [[NumberData]] internal slot is the Number value represented by this
Number object.
is the initial value of the "BigInt" property of the global
object.
performs a type conversion when called as a function rather than as a constructor.
is not intended to be used with the new operator or to be subclassed. It may be
used as the value of an extends clause of a class definition but a
super call to the BigInt constructor will cause an exception.
21.2.1.1 BigInt ( value )
This function performs the following steps when called:
If NewTarget is not undefined, throw a
TypeError exception.
The abstract operation NumberToBigInt takes argument number (a Number) and
returns either a normal completion
containing a BigInt or a throw
completion. It performs the following steps when called:
If number is not an integral Number,
throw a RangeError exception.
The phrase “this BigInt value” within the specification of a method refers to the result returned
by calling the abstract operation ThisBigIntValue with the
this value of the method invocation passed as the argument.
21.2.3.1 BigInt.prototype.constructor
The initial value of BigInt.prototype.constructor is %BigInt%.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must
implement this method as specified in the ECMA-402 specification. If an ECMAScript
implementation does not include the ECMA-402 API the following specification of this method
is used:
This method produces a String value that represents this BigInt value formatted according to
the conventions of the host environment's current locale. This
method is implementation-defined, and it is
permissible, but not encouraged, for it to return the same thing as toString.
The meanings of the optional parameters to this method are defined in the ECMA-402
specification; implementations that do not include ECMA-402 support must not use those
parameter positions for anything else.
21.2.3.3 BigInt.prototype.toString ( [ radix ] )
Note
The optional radix should be an integral Number value
in the inclusive interval from
2𝔽 to 36𝔽. If
radix is undefined then
10𝔽 is used as the value of radix.
This method performs the following steps when called:
This method is not generic; it throws a TypeError exception if its
this value is not a
BigInt or a BigInt object. Therefore, it cannot be transferred to
other kinds of objects for use as a method.
The initial value of the %Symbol.toStringTag% property is the
String value "BigInt".
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: true }.
21.2.4 Properties of BigInt Instances
BigInt instances are ordinary objects that inherit properties from the
BigInt prototype
object. BigInt instances also have a [[BigIntData]] internal slot. The [[BigIntData]] internal slot is the BigInt value represented by this
BigInt object.
21.3 The Math Object
The Math object:
is %Math%.
is the initial value of the "Math" property of the global
object.
does not have a [[Construct]] internal method; it cannot be used as a
constructor
with the new operator.
does not have a [[Call]] internal method; it cannot be invoked as a
function.
Note
In this specification, the phrase “the Number value forx” has a
technical meaning defined in 6.1.6.1.
21.3.1 Value Properties of the Math Object
21.3.1.1 Math.E
The Number
value fore, the base of the natural logarithms, which is
approximately 2.7182818284590452354.
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
21.3.1.2 Math.LN10
The Number
value for the natural logarithm of 10, which is approximately
2.302585092994046.
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
21.3.1.3 Math.LN2
The Number
value for the natural logarithm of 2, which is approximately
0.6931471805599453.
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
21.3.1.4 Math.LOG10E
The Number
value for the base-10 logarithm of e, the base of the natural
logarithms; this value is approximately 0.4342944819032518.
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
Note
The value of Math.LOG10E is approximately the reciprocal of the value of
Math.LN10.
21.3.1.5 Math.LOG2E
The Number
value for the base-2 logarithm of e, the base of the natural
logarithms; this value is approximately 1.4426950408889634.
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
Note
The value of Math.LOG2E is approximately the reciprocal of the value of
Math.LN2.
21.3.1.6 Math.PI
The Number
value for π, the ratio of the circumference of a circle to its
diameter, which is approximately 3.1415926535897932.
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
21.3.1.7 Math.SQRT1_2
The Number
value for the square root of ½, which is approximately
0.7071067811865476.
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
Note
The value of Math.SQRT1_2 is approximately the reciprocal of the value
of Math.SQRT2.
21.3.1.8 Math.SQRT2
The Number
value for the square root of 2, which is approximately
1.4142135623730951.
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
21.3.1.9 Math [ %Symbol.toStringTag% ]
The initial value of the %Symbol.toStringTag% property is the
String value "Math".
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: true }.
21.3.2 Function Properties of the Math Object
Note
The behaviour of the functions acos, acosh, asin,
asinh, atan, atanh, atan2,
cbrt, cos, cosh, exp,
expm1, hypot, log, log1p,
log2, log10, pow, random,
sin, sinh, tan, and tanh is not
precisely specified here except to require specific results for certain argument values
that represent boundary cases of interest. For other argument values, these functions
are intended to compute approximations to the results of familiar mathematical
functions, but some latitude is allowed in the choice of approximation algorithms. The
general intent is that an implementer should be able to use the same mathematical
library for ECMAScript on a given hardware platform that is available to C programmers
on that platform.
Although the choice of algorithms is left to the implementation, it is recommended (but
not specified by this standard) that implementations use the approximation algorithms
for IEEE
754-2019 arithmetic contained in fdlibm, the freely
distributable mathematical library from Sun Microsystems (http://www.netlib.org/fdlibm).
21.3.2.1 Math.abs ( x )
This function returns the absolute value of x; the result has the same magnitude
as x but has positive sign.
This function returns the inverse tangent of the quotient y / x of the arguments y and
x, where the signs of y and x are used to determine the
quadrant of the result. Note that it is intentional and traditional for the two-argument
inverse tangent function that the argument named y be first and the argument
named x be second. The result is expressed in radians and is in the inclusive
interval from -π to +π.
This function returns the result of subtracting 1 from the exponential function of
x (e raised to the power of x, where e is the
base of the natural logarithms). The result is computed in a way that is accurate even when
the value of x is close to 0.
This function returns the greatest (closest to +∞) integral Number value that is
not greater than x. If x is already an integral
Number, the result is x.
Let n16 be the result of converting n to IEEE
754-2019 binary16 format using roundTiesToEven mode.
Let n64 be the result of converting n16 to IEEE
754-2019 binary64 format.
Return the ECMAScript Number value corresponding to n64.
Note
This operation is not the same as casting to binary32 and then to binary16 because of
the possibility of double-rounding: consider the number k =
1.00048828125000022204𝔽, for example, for which
Math.f16round(k) is 1.0009765625𝔽, but
Math.f16round(Math.fround(k)) is 1𝔽.
Not all platforms provide native support for casting from binary64 to binary16. There
are various libraries which can provide this, including the MIT-licensed half library. Alternatively, it is
possible to first cast from binary64 to binary32 under roundTiesToEven and then
check whether the result could lead to incorrect double-rounding. The cases which
could can be handled explicitly by adjusting the mantissa of the binary32 value so
that it is the value which would be produced by performing the initial cast under
roundTiesToOdd. Casting the adjusted value to binary16 under roundTiesToEven then
produces the correct value.
21.3.2.19 Math.hypot ( ...args )
Given zero or more arguments, this function returns the square root of the sum of squares of
its arguments.
Implementations should take care to avoid the loss of precision from overflows and
underflows that are prone to occur in naive implementations when this function is
called with two or more arguments.
21.3.2.20 Math.imul ( x, y )
This function performs the following steps when called:
This function returns a Number value with positive sign, greater than or equal to
+0𝔽 but strictly less than 1𝔽,
chosen randomly or pseudo randomly with approximately uniform distribution over that range,
using an implementation-defined algorithm or
strategy.
Each Math.random function created for distinct realms must produce a distinct sequence
of values from successive calls.
21.3.2.29 Math.round ( x )
This function returns the Number value that is closest to x and is integral. If
two integral
Numbers are equally close to x, then the result is the
Number value that is closer to +∞. If x is already integral, the result is
x.
Return the integral Number closest to
n, preferring the Number closer to +∞ in the case of a tie.
Note 1
Math.round(3.5) returns 4, but Math.round(-3.5) returns -3.
Note 2
The value of Math.round(x) is not always the same as the value of
Math.floor(x + 0.5). When x is
-0𝔽 or x is less than
-0𝔽 but greater than or equal to
-0.5𝔽, Math.round(x) returns
-0𝔽, but Math.floor(x + 0.5) returns
+0𝔽. Math.round(x) may also differ from
the value of Math.floor(x + 0.5)because of internal rounding when
computing x + 0.5.
21.3.2.30 Math.sign ( x )
This function returns the sign of x, indicating whether x is positive,
negative, or zero.
If n is not finite or n is either
+0𝔽 or -0𝔽, return
n.
If n < 1𝔽 and n >
+0𝔽, return +0𝔽.
If n < -0𝔽 and n >
-1𝔽, return -0𝔽.
Return the integral Number nearest n
in the direction of +0𝔽.
21.4 Date Objects
21.4.1 Overview of Date Objects and Definitions of Abstract
Operations
The following abstract operations
operate on time values (defined in 21.4.1.1). Note that, in every
case, if any argument to one of these functions is NaN, the result will be
NaN.
21.4.1.1 Time Values and Time Range
Time measurement in ECMAScript is analogous to time measurement in POSIX, in particular
sharing definition in terms of the proleptic Gregorian calendar, an epoch of midnight at the beginning of 1 January 1970 UTC, and an
accounting of every day as comprising exactly 86,400 seconds (each of which is 1000
milliseconds long).
An ECMAScript time value is a Number, either
a finiteintegral
Number representing an instant in time to millisecond precision or
NaN representing no specific instant. A time value that is a multiple of
24 × 60 × 60 × 1000 = 86,400,000 (i.e., is 86,400,000 ×
d for some integerd) represents the instant at the
start of the UTC day that follows the epoch by d whole UTC days (preceding the
epoch for negative
d). Every other finite time value t is defined relative to
the greatest preceding time value s that is such a multiple, and represents the
instant that occurs within the same UTC day as s but follows it by (t
- s) milliseconds.
Time values do not account for UTC leap seconds—there are no time values representing
instants within positive leap seconds, and there are time values representing instants
removed from the UTC timeline by negative leap seconds. However, the definition of time
values nonetheless yields piecewise alignment with UTC, with discontinuities only at leap
second boundaries and zero difference outside of leap seconds.
A Number can exactly represent all integers from -9,007,199,254,740,992 to
9,007,199,254,740,992 (21.1.2.8 and 21.1.2.6). A time value supports
a slightly smaller range of -8,640,000,000,000,000 to 8,640,000,000,000,000 milliseconds.
This yields a supported time value range of exactly -100,000,000 days to 100,000,000 days
relative to midnight at the beginning of 1 January 1970 UTC.
The exact moment of midnight at the beginning of 1 January 1970 UTC is represented by the
time value +0𝔽.
Note
In the proleptic Gregorian calendar, leap years are precisely those which are both
divisible by 4 and either divisible by 400 or not divisible by 100.
The 400 year cycle of the proleptic Gregorian calendar contains 97 leap years. This
yields an average of 365.2425 days per year, which is 31,556,952,000 milliseconds.
Therefore, the maximum range a Number could represent exactly with millisecond
precision is approximately -285,426 to 285,426 years relative to 1970. The smaller
range supported by a time value as specified in this section is approximately
-273,790 to 273,790 years relative to 1970.
21.4.1.2 Time-related Constants
These constants are referenced by algorithms in the following sections.
The abstract operation Day takes argument t (a finitetime value) and returns an
integral
Number. It returns the day number of the day in which t
falls. It performs the following steps when called:
The abstract operation TimeWithinDay takes argument t (a finitetime value) and returns an
integral
Number in the interval from +0𝔽
(inclusive) to msPerDay (exclusive). It returns the number of
milliseconds since the start of the day in which t falls. It performs the
following steps when called:
The abstract operation DaysInYear takes argument y (an integral
Number) and returns 365𝔽 or
366𝔽. It returns the number of days in year y.
Leap years have 366 days; all other years have 365. It performs the following steps when
called:
The abstract operation DayFromYear takes argument y (an integral
Number) and returns an integral Number. It returns
the day number of the first day of year y. It performs the following steps when
called:
NOTE: In the following steps,
numYears1, numYears4, numYears100, and
numYears400 represent the number of years divisible by 1, 4, 100, and
400, respectively, that occur between the epoch and the start of year y. The
number is negative if y is before the epoch.
The abstract operation TimeFromYear takes argument y (an integral
Number) and returns a time value. It returns the
time value of the start of
year y. It performs the following steps when called:
The abstract operation YearFromTime takes argument t (a finitetime value) and returns an
integral
Number. It returns the year in which t falls. It performs
the following steps when called:
The abstract operation InLeapYear takes argument t (a finitetime value) and returns
+0𝔽 or 1𝔽. It returns
1𝔽 if t is within a leap year and
+0𝔽 otherwise. It performs the following steps when called:
The abstract operation MonthFromTime takes argument t (a finitetime value) and returns an
integral
Number in the inclusive interval from
+0𝔽 to 11𝔽. It returns a
Number identifying the month in which t falls. A month value of
+0𝔽 specifies January; 1𝔽
specifies February; 2𝔽 specifies March;
3𝔽 specifies April; 4𝔽
specifies May; 5𝔽 specifies June;
6𝔽 specifies July; 7𝔽
specifies August; 8𝔽 specifies September;
9𝔽 specifies October; 10𝔽
specifies November; and 11𝔽 specifies December. Note that
MonthFromTime(+0𝔽) =
+0𝔽, corresponding to Thursday, 1 January 1970.
It performs the following steps when called:
The abstract operation DateFromTime takes argument t (a finitetime value) and returns an
integral
Number in the inclusive interval from
1𝔽 to 31𝔽. It returns the day
of the month in which t falls. It performs the following steps when called:
The abstract operation WeekDay takes argument t (a finitetime value) and returns an
integral
Number in the inclusive interval from
+0𝔽 to 6𝔽. It returns a Number
identifying the day of the week in which t falls. A weekday value of
+0𝔽 specifies Sunday; 1𝔽
specifies Monday; 2𝔽 specifies Tuesday;
3𝔽 specifies Wednesday; 4𝔽
specifies Thursday; 5𝔽 specifies Friday; and
6𝔽 specifies Saturday. Note that WeekDay(+0𝔽) =
4𝔽, corresponding to Thursday, 1 January 1970.
It performs the following steps when called:
The abstract operation HourFromTime takes argument t (a finitetime value) and returns an
integral
Number in the inclusive interval from
+0𝔽 to 23𝔽. It returns the
hour of the day in which t falls. It performs the following steps when called:
The abstract operation MinFromTime takes argument t (a finitetime value) and returns an
integral
Number in the inclusive interval from
+0𝔽 to 59𝔽. It returns the
minute of the hour in which t falls. It performs the following steps when called:
The abstract operation SecFromTime takes argument t (a finitetime value) and returns an
integral
Number in the inclusive interval from
+0𝔽 to 59𝔽. It returns the
second of the minute in which t falls. It performs the following steps when
called:
The abstract operation msFromTime takes argument t (a finitetime value) and returns an
integral
Number in the inclusive interval from
+0𝔽 to 999𝔽. It returns the
millisecond of the second in which t falls. It performs the following steps when
called:
Time zones in ECMAScript are represented by time zone identifiers, which are Strings composed entirely of code
units in the inclusive interval from 0x0000 to 0x007F.
Time zones supported by an ECMAScript implementation may be available named time zones,
represented by the [[Identifier]] field of the Time Zone Identifier Records
returned by AvailableNamedTimeZoneIdentifiers,
or offset time zones, represented by
Strings for which IsTimeZoneOffsetString returns
true.
A primary time zone
identifier is the preferred identifier for an available named time zone.
A non-primary time zone
identifier is an identifier for an available named time zone that is not a primary
time zone identifier.
An available named time
zone identifier is either a primary time zone identifier or a non-primary time
zone identifier.
Each available named time zone identifier is associated with exactly one available named
time zone.
Each available named time zone is associated with exactly one primary time zone identifier
and zero or more non-primary time zone identifiers.
ECMAScript implementations must support an available named time zone with the identifier
"UTC", which must be the primary time zone identifier for the UTC time
zone.
In addition, implementations may support any number of other available named time zones.
Implementations that follow the requirements for time zones as described in the ECMA-402
Internationalization API specification are called time zone aware.
Time zone aware implementations must support available named time zones corresponding to the
Zone and Link names of the IANA Time Zone Database, and only such names.
In time zone aware implementations, a primary time zone identifier is a Zone name, and a
non-primary time zone identifier is a Link name, respectively, in the IANA Time Zone
Database except as specifically overridden by AvailableNamedTimeZoneIdentifiers
as specified in the ECMA-402 specification.
Implementations that do not support the entire IANA Time Zone Database are still recommended
to use IANA Time Zone Database names as identifiers to represent time zones.
When the input represents a local time occurring more than once because of a negative time
zone transition (e.g. when daylight saving time ends or the time zone offset is decreased
due to a time zone rule change), the returned List will have more
than one element and will be sorted by ascending numerical value.
When the input represents a local time skipped because of a positive time zone transition
(e.g. when daylight saving time begins or the time zone offset is increased due to a time
zone rule change), the returned List
will be empty.
Otherwise, the returned List
will have one element.
The default implementation of GetNamedTimeZoneEpochNanoseconds, to be used for ECMAScript
implementations that do not include local political rules for any time zones, performs the
following steps when called:
1:30 AM on 5 November 2017 in America/New_York is repeated twice, so
GetNamedTimeZoneEpochNanoseconds("America/New_York", 2017, 11, 5,
1, 30, 0, 0, 0, 0) would return a List of length
2 in which the first element represents 05:30 UTC (corresponding with 01:30 US
Eastern Daylight Time at UTC offset -04:00) and the second element represents 06:30
UTC (corresponding with 01:30 US Eastern Standard Time at UTC offset -05:00).
2:30 AM on 12 March 2017 in America/New_York does not exist, so
GetNamedTimeZoneEpochNanoseconds("America/New_York", 2017, 3, 12,
2, 30, 0, 0, 0, 0) would return an empty List.
The implementation-defined abstract
operation GetNamedTimeZoneOffsetNanoseconds takes arguments timeZoneIdentifier (a
String) and epochNanoseconds (a BigInt) and returns an integer.
The returned integer represents the offset from UTC of the named
time zone identified by timeZoneIdentifier, at the instant corresponding with
epochNanoseconds relative to the epoch, both in nanoseconds.
The default implementation of GetNamedTimeZoneOffsetNanoseconds, to be used for ECMAScript
implementations that do not include local political rules for any time zones, performs the
following steps when called:
Time zone aware implementations,
including all implementations that implement the ECMA-402 Internationalization API, must
implement the AvailableNamedTimeZoneIdentifiers abstract operation as specified in the
ECMA-402 specification.
For implementations that are not time zone aware,
AvailableNamedTimeZoneIdentifiers performs the following steps when called:
If the implementation does not include local political rules for any time zones,
then
The implementation-defined abstract
operation SystemTimeZoneIdentifier takes no arguments and returns a String.
It returns a String representing the host environment's current time zone, which
is either a String representing a UTC offset for which IsTimeZoneOffsetString returns
true, or a primary time zone identifier.
It performs the following steps when called:
If the implementation only supports the UTC time zone, return
"UTC".
To ensure the level of functionality that implementations commonly provide in the
methods of the Date object, it is recommended that SystemTimeZoneIdentifier return
an IANA time zone name corresponding to the host environment's
time zone setting, if such a thing exists.
GetNamedTimeZoneEpochNanoseconds
and GetNamedTimeZoneOffsetNanoseconds
must reflect the local political rules for standard time and daylight saving time in
that time zone, if such rules exist.
For example, if the host environment is a browser on a
system where the user has chosen US Eastern Time as their time zone,
SystemTimeZoneIdentifier returns "America/New_York".
21.4.1.25 LocalTime ( t )
The abstract operation LocalTime takes argument t (a finitetime value) and returns an
integral
Number.
It converts t from UTC to local time.
The local political rules for standard time and daylight saving time in effect at
t should be used to determine the result in the way specified in this section.
It performs the following steps when called:
Two different input time
valuestUTC are converted to the same
local time tlocal at a negative time
zone transition when there are repeated times (e.g. the daylight saving time ends or
the time zone adjustment is decreased.).
LocalTime(UTC(tlocal))
is not necessarily always equal to tlocal. Correspondingly, UTC(LocalTime(tUTC))
is not necessarily always equal to tUTC.
21.4.1.26 UTC ( t )
The abstract operation UTC takes argument t (a Number) and returns a time value.
It converts t from local time to a UTC time value.
The local political rules for standard time and daylight saving time in effect at
t should be used to determine the result in the way specified in this section.
It performs the following steps when called:
NOTE: The following steps ensure that when t represents local
time repeating multiple times at a negative time zone transition (e.g. when
the daylight saving time ends or the time zone offset is decreased due to a
time zone rule change) or skipped local time at a positive time zone
transition (e.g. when the daylight saving time starts or the time zone
offset is increased due to a time zone rule change), t is
interpreted using the time zone offset before the transition.
If possibleInstants is not empty, then
Let disambiguatedInstant be
possibleInstants[0].
Else,
NOTE: t represents a local time skipped at a positive
time zone transition (e.g. due to daylight saving time starting or a
time zone rule change increasing the UTC offset).
Input t is nominally a time value but
may be any Number value.
The algorithm must not limit t to the time value range, so that
inputs corresponding with a boundary of the time value
range can be supported regardless of local UTC offset.
For example, the maximum time value is 8.64 ×
1015, corresponding with "+275760-09-13T00:00:00Z".
In an environment where the local time zone offset is ahead of UTC by 1 hour at that
instant, it is represented by the larger input of 8.64 × 1015 + 3.6 ×
106, corresponding with "+275760-09-13T01:00:00+01:00".
1:30 AM on 5 November 2017 in America/New_York is repeated twice (fall backward),
but it must be interpreted as 1:30 AM UTC-04 instead of 1:30 AM UTC-05.
In UTC(TimeClip(MakeDate(MakeDay(2017, 10, 5), MakeTime(1, 30, 0, 0)))), the value of
offsetMs is -4 × msPerHour.
2:30 AM on 12 March 2017 in America/New_York does not exist, but it must be
interpreted as 2:30 AM UTC-05 (equivalent to 3:30 AM UTC-04).
In UTC(TimeClip(MakeDate(MakeDay(2017, 2, 12), MakeTime(2, 30, 0, 0)))), the value of
offsetMs is -5 × msPerHour.
Note 2
UTC(LocalTime(tUTC))
is not necessarily always equal to tUTC. Correspondingly, LocalTime(UTC(tlocal))
is not necessarily always equal to tlocal.
21.4.1.27 MakeTime ( hour, min,
sec, ms )
The abstract operation MakeTime takes arguments hour (a Number), min (a
Number), sec (a Number), and ms (a Number) and returns a Number. It
calculates a number of milliseconds. It performs the following steps when called:
The arithmetic in MakeTime is floating-point arithmetic, which is not associative, so
the operations must be performed in the correct order.
21.4.1.28 MakeDay ( year, month,
date )
The abstract operation MakeDay takes arguments year (a Number), month
(a Number), and date (a Number) and returns a Number. It calculates a number of
days. It performs the following steps when called:
If year is not finite, month is not finite, or
date is not finite, return NaN.
The abstract operation MakeDate takes arguments day (a Number) and time
(a Number) and returns a Number. It calculates a number of milliseconds. It performs the
following steps when called:
If day is not finite or time is not finite, return
NaN.
The abstract operation MakeFullYear takes argument year (a Number) and returns an
integral
Number or NaN. It returns the full year associated
with the integer
part of year, interpreting any value in the inclusive interval from 0
to 99 as a count of years since the start of 1900. For alignment with the proleptic
Gregorian calendar, "full year" is defined as the signed count of complete years since the
start of year 0 (1 B.C.). It performs the following steps when called:
The abstract operation TimeClip takes argument time (a Number) and returns a
Number. It calculates a number of milliseconds. It performs the following steps when called:
ECMAScript defines a string interchange format for date-times based upon a simplification of
the ISO 8601 calendar date extended format. The format is as follows:
YYYY-MM-DDTHH:mm:ss.sssZ
Where the elements are as follows:
YYYY
is the year in the proleptic Gregorian calendar as four decimal digits from
0000 to 9999, or as an expanded year of
"+" or "-" followed by six decimal
digits.
-
"-" (hyphen) appears literally twice in the string.
MM
is the month of the year as two decimal digits from 01 (January) to 12
(December).
DD
is the day of the month as two decimal digits from 01 to 31.
T
"T" appears literally in the string, to indicate the
beginning of the time element.
HH
is the number of complete hours that have passed since midnight as two
decimal digits from 00 to 24.
:
":" (colon) appears literally twice in the string.
mm
is the number of complete minutes since the start of the hour as two decimal
digits from 00 to 59.
ss
is the number of complete seconds since the start of the minute as two
decimal digits from 00 to 59.
.
"." (dot) appears literally in the string.
sss
is the number of complete milliseconds since the start of the second as
three decimal digits.
Z
is the UTC offset representation specified as "Z" (for
UTC with no offset) or as either "+" or
"-" followed by a time expression HH:mm (a
subset of the time zone offset
string format for indicating local time ahead of or
behind UTC, respectively)
This format includes date-only forms:
YYYY
YYYY-MM
YYYY-MM-DD
It also includes “date-time” forms that consist of one of the above date-only forms
immediately followed by one of the following time forms with an optional UTC offset
representation appended:
THH:mm
THH:mm:ss
THH:mm:ss.sss
A string containing out-of-bounds or nonconforming elements is not a valid instance of this
format.
Note 1
As every day both starts and ends with midnight, the two notations 00:00
and 24:00 are available to distinguish the two midnights that can be
associated with one date. This means that the following two notations refer to
exactly the same point in time: 1995-02-04T24:00 and
1995-02-05T00:00. This interpretation of the latter form as "end of a
calendar day" is consistent with ISO 8601, even though that specification reserves
it for describing time intervals and does not permit it within representations of
single points in time.
Note 2
There exists no international standard that specifies abbreviations for civil time
zones like CET, EST, etc. and sometimes the same abbreviation is even used for two
very different time zones. For this reason, both ISO 8601 and this format specify
numeric representations of time zone offsets.
21.4.1.32.1 Expanded Years
Covering the full time value range of
approximately 273,790 years forward or backward from 1 January 1970 (21.4.1.1) requires
representing years before 0 or after 9999. ISO 8601 permits expansion of the year
representation, but only by mutual agreement of the partners in information interchange.
In the simplified ECMAScript format, such an expanded year representation shall have 6
digits and is always prefixed with a + or - sign. The year 0 is considered positive and
must be prefixed with a + sign. The representation of the year 0 as -000000 is invalid.
Strings matching the Date Time String Format with
expanded years representing instants in time outside the range of a time value are treated as
unrecognizable by Date.parse and cause that
function to return NaN without falling back to
implementation-specific behaviour or heuristics.
Note
Examples of date-time values with expanded years:
-271821-04-20T00:00:00Z
271822 B.C.
-000001-01-01T00:00:00Z
2 B.C.
+000000-01-01T00:00:00Z
1 B.C.
+000001-01-01T00:00:00Z
1 A.D.
+001970-01-01T00:00:00Z
1970 A.D.
+002009-12-15T00:00:00Z
2009 A.D.
+275760-09-13T00:00:00Z
275760 A.D.
21.4.1.33 Time Zone Offset String Format
ECMAScript defines a string interchange format for UTC offsets, derived from ISO 8601.
The format is described by the following grammar.
The abstract operation IsTimeZoneOffsetString takes argument offsetString (a
String) and returns a Boolean. The return value indicates whether
offsetString conforms to the grammar given by UTCOffset. It performs the following steps
when called:
The abstract operation ParseTimeZoneOffsetString takes argument offsetString
(a String) and returns an integer. The return value is the UTC offset, as a
number of nanoseconds, that corresponds to the String offsetString. It
performs the following steps when called:
If parsedSign is the single code point U+002D (HYPHEN-MINUS), then
Let sign be -1.
Else,
Let sign be 1.
NOTE: Applications of StringToNumber below do not
lose precision, since each of the parsed values is guaranteed to be a
sufficiently short string of decimal digits.
is the initial value of the "Date" property of the global
object.
creates and initializes a new Date when called as a constructor.
returns a String representing the current time (UTC) when called as a function rather than
as a constructor.
is a function whose behaviour differs based upon the number and types of its arguments.
may be used as the value of an extends clause of a class definition. Subclass
constructors that intend to inherit the specified
Date behaviour must include a super call to the Date constructor to
create and initialize the subclass instance with a [[DateValue]]
internal slot.
21.4.2.1 Date ( ...values )
This function performs the following steps when called:
If NewTarget is undefined, then
Let now be the time
value (UTC) identifying the current time.
This function returns the time value designating the UTC
date and time of the occurrence of the call to it.
21.4.3.2 Date.parse ( string )
This function applies the ToString operator to its argument. If ToString results
in an abrupt completion
the Completion Record is
immediately returned. Otherwise, this function interprets the resulting String as a date and
time; it returns a Number, the UTC time value
corresponding to the date and time. The String may be interpreted as a local time, a UTC
time, or a time in some other time zone, depending on the contents of the String. The
function first attempts to parse the String according to the format described in Date Time
String Format (21.4.1.32), including expanded
years. If the String does not conform to that format the function may fall back to any
implementation-specific heuristics or implementation-specific date formats. Strings that are
unrecognizable or contain out-of-bounds format element values shall cause this function to
return NaN.
If the String conforms to the Date Time String Format,
substitute values take the place of absent format elements. When the MM or
DD elements are absent, "01" is used. When the
HH, mm, or ss elements are absent,
"00" is used. When the sss element is absent,
"000" is used. When the UTC offset representation is absent, date-only
forms are interpreted as a UTC time and date-time forms are interpreted as a local time.
If x is any Date whose milliseconds amount is zero within a particular
implementation of ECMAScript, then all of the following expressions should produce the same
numeric value in that implementation, if all the properties referenced have their initial
values:
is not required to produce the same Number value as the preceding three expressions and, in
general, the value produced by this function is implementation-defined
when given any String value that does not conform to the Date Time String Format (21.4.1.32) and that could not be
produced in that implementation by the toString or toUTCString
method.
This function differs from the Date constructor in two ways: it returns a
time value as a
Number, rather than creating a Date, and it interprets the arguments in UTC rather
than as local time.
Unless explicitly defined otherwise, the methods of the Date prototype object defined below are
not generic and the this value passed to them must be an object that has a
[[DateValue]] internal slot that has been initialized to a time value.
21.4.4.1 Date.prototype.constructor
The initial value of Date.prototype.constructor is %Date%.
21.4.4.2 Date.prototype.getDate ( )
This method performs the following steps when called:
If month is not present, this method behaves as if month was
present with the value getMonth(). If date is not present,
it behaves as if date was present with the value getDate().
21.4.4.22 Date.prototype.setHours ( hour [ ,
min [ , sec [ , ms ] ] ] )
This method performs the following steps when called:
If min is not present, this method behaves as if min was
present with the value getMinutes(). If sec is not present,
it behaves as if sec was present with the value
getSeconds(). If ms is not present, it behaves as if
ms was present with the value getMilliseconds().
21.4.4.23 Date.prototype.setMilliseconds ( ms )
This method performs the following steps when called:
If sec is not present, this method behaves as if sec was
present with the value getSeconds(). If ms is not present,
this behaves as if ms was present with the value
getMilliseconds().
21.4.4.25 Date.prototype.setMonth ( month [ ,
date ] )
This method performs the following steps when called:
If month is not present, this method behaves as if month was
present with the value getUTCMonth(). If date is not
present, it behaves as if date was present with the value
getUTCDate().
21.4.4.30 Date.prototype.setUTCHours ( hour [ ,
min [ , sec [ , ms ] ] ] )
This method performs the following steps when called:
If min is not present, this method behaves as if min was
present with the value getUTCMinutes(). If sec is not
present, it behaves as if sec was present with the value
getUTCSeconds(). If ms is not present, it behaves as if
ms was present with the value getUTCMilliseconds().
21.4.4.31 Date.prototype.setUTCMilliseconds ( ms )
This method performs the following steps when called:
If sec is not present, this method behaves as if sec was
present with the value getUTCSeconds(). If ms is not
present, it behaves as if ms was present with the value return by
getUTCMilliseconds().
21.4.4.33 Date.prototype.setUTCMonth ( month [ ,
date ] )
This method performs the following steps when called:
If tv corresponds with a year that cannot be represented in the Date Time String Format,
throw a RangeError exception.
Return a String representation of tv in the Date Time String Format
on the UTC time scale, including all format elements and the UTC offset
representation "Z".
21.4.4.37 Date.prototype.toJSON ( key )
This method provides a String representation of a Date for use by JSON.stringify
(25.5.2).
This method is intentionally generic; it does not require that its
this value be a Date. Therefore, it can be transferred to other
kinds of objects for use as a method. However, it does require that any such object
have a toISOString method.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must
implement this method as specified in the ECMA-402 specification. If an ECMAScript
implementation does not include the ECMA-402 API the following specification of this method
is used:
This method returns a String value. The contents of the String are implementation-defined, but are
intended to represent the “date” portion of the Date in the current time zone in a
convenient, human-readable form that corresponds to the conventions of the host
environment's current locale.
The meaning of the optional parameters to this method are defined in the ECMA-402
specification; implementations that do not include ECMA-402 support must not use those
parameter positions for anything else.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must
implement this method as specified in the ECMA-402 specification. If an ECMAScript
implementation does not include the ECMA-402 API the following specification of this method
is used:
This method returns a String value. The contents of the String are implementation-defined, but are
intended to represent the Date in the current time zone in a convenient, human-readable form
that corresponds to the conventions of the host environment's current
locale.
The meaning of the optional parameters to this method are defined in the ECMA-402
specification; implementations that do not include ECMA-402 support must not use those
parameter positions for anything else.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must
implement this method as specified in the ECMA-402 specification. If an ECMAScript
implementation does not include the ECMA-402 API the following specification of this method
is used:
This method returns a String value. The contents of the String are implementation-defined, but are
intended to represent the “time” portion of the Date in the current time zone in a
convenient, human-readable form that corresponds to the conventions of the host
environment's current locale.
The meaning of the optional parameters to this method are defined in the ECMA-402
specification; implementations that do not include ECMA-402 support must not use those
parameter positions for anything else.
21.4.4.41 Date.prototype.toString ( )
This method performs the following steps when called:
For any Date d such that
d.[[DateValue]] is evenly divisible by 1000,
the result of Date.parse(d.toString()) = d.valueOf(). See
21.4.3.2.
Note 2
This method is not generic; it throws a TypeError exception if its
this value is not a Date. Therefore, it cannot be transferred to
other kinds of objects for use as a method.
21.4.4.41.1 TimeString ( tv )
The abstract operation TimeString takes argument tv (a Number, but not
NaN) and returns a String. It performs the following steps when
called:
Return the string-concatenation of
weekday, the code unit 0x0020 (SPACE), month, the code
unit 0x0020 (SPACE), day, the code unit 0x0020 (SPACE),
yearSign, and paddedYear.
Table 65: Names of days of the week
Number
Name
+0𝔽
"Sun"
1𝔽
"Mon"
2𝔽
"Tue"
3𝔽
"Wed"
4𝔽
"Thu"
5𝔽
"Fri"
6𝔽
"Sat"
Table 66: Names of months of the year
Number
Name
+0𝔽
"Jan"
1𝔽
"Feb"
2𝔽
"Mar"
3𝔽
"Apr"
4𝔽
"May"
5𝔽
"Jun"
6𝔽
"Jul"
7𝔽
"Aug"
8𝔽
"Sep"
9𝔽
"Oct"
10𝔽
"Nov"
11𝔽
"Dec"
21.4.4.41.3 TimeZoneString ( tv )
The abstract operation TimeZoneString takes argument tv (an integral
Number) and returns a String. It performs the following steps
when called:
Let tzName be an implementation-defined
string that is either the empty String or the string-concatenation of the
code unit 0x0020 (SPACE), the code unit 0x0028 (LEFT PARENTHESIS), an implementation-defined
timezone name, and the code unit 0x0029 (RIGHT PARENTHESIS).
Return the string-concatenation of
offsetSign, offsetHour, offsetMin, and
tzName.
21.4.4.41.4 ToDateString ( tv )
The abstract operation ToDateString takes argument tv (an integral
Number or NaN) and returns a String. It
performs the following steps when called:
This method returns a String value representing the instant in time corresponding to the
this value. The format of the String is based upon "HTTP-date" from RFC
7231, generalized to support the full range of times supported by ECMAScript Dates.
Return the string-concatenation of
weekday, ",", the code unit 0x0020 (SPACE),
day, the code unit 0x0020 (SPACE), month, the code unit 0x0020
(SPACE), yearSign, paddedYear, the code unit 0x0020 (SPACE),
and TimeString(tv).
21.4.4.44 Date.prototype.valueOf ( )
This method performs the following steps when called:
21.4.4.45 Date.prototype [ %Symbol.toPrimitive% ] (
hint )
This method is called by ECMAScript language operators to convert a Date to a primitive
value. The allowed values for hint are "default",
"number", and "string". Dates are unique among
built-in ECMAScript object in that they treat "default" as being
equivalent to "string", All other built-in ECMAScript objects treat
"default" as being equivalent to "number".
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: true }.
The value of the "name" property of this method is
"[Symbol.toPrimitive]".
21.4.5 Properties of Date Instances
Date instances are ordinary objects that inherit properties from the
Date prototype
object. Date instances also have a [[DateValue]]
internal slot. The [[DateValue]] internal slot is the time value represented by this
Date.
is the initial value of the "String" property of the global
object.
creates and initializes a new String object when called as a constructor.
performs a type conversion when called as a function rather than as a constructor.
may be used as the value of an extends clause of a class definition. Subclass
constructors that intend to inherit the specified
String behaviour must include a super call to the String constructor to
create and initialize the subclass instance with a [[StringData]]
internal slot.
22.1.1.1 String ( value )
This function performs the following steps when called:
This function may be called with a variable number of arguments. The first argument is
template and the remainder of the arguments form the Listsubstitutions.
It performs the following steps when called:
Let substitutionCount be the number of elements in
substitutions.
This function is intended for use as a tag function of a Tagged Template (13.3.11). When called as such,
the first argument will be a well formed template object and the rest parameter will
contain the substitution values.
Unless explicitly stated otherwise, the methods of the String prototype object defined below are
not generic and the this value passed to them must be either a String value
or an object that has a [[StringData]] internal slot that has been
initialized to a String value.
This method returns a single element String containing the code unit at index
pos within the String value resulting from converting this object to a
String. If there is no element at that index, the result is the empty String. The
result is a
String value, not a String object.
If pos is an integral Number, then the result of
x.charAt(pos) is equivalent to the result of
x.substring(pos, pos + 1).
This method performs the following steps when called:
If position < 0 or position ≥ size, return the
empty String.
Return the substring of S from
position to position + 1.
Note 2
This method is intentionally generic; it does not require that its
this value be a String object. Therefore, it can be transferred
to other kinds of objects for use as a method.
22.1.3.3 String.prototype.charCodeAt ( pos )
Note 1
This method returns a Number (a non-negative integral Number less
than 216) that is the numeric value of the code unit at index
pos within the String resulting from converting this object to a String.
If there is no element at that index, the result is NaN.
This method performs the following steps when called:
Return the Number value for the numeric value
of the code unit at index position within the String S.
Note 2
This method is intentionally generic; it does not require that its
this value be a String object. Therefore it can be transferred to
other kinds of objects for use as a method.
22.1.3.4 String.prototype.codePointAt ( pos )
Note 1
This method returns a non-negative integral Number less
than or equal to 0x10FFFF𝔽 that is the numeric value
of the UTF-16 encoded code point (6.1.4)
starting at the string element at index pos within the String resulting
from converting this object to a String. If there is no element at that index, the
result is undefined. If a valid UTF-16 surrogate
pair does not begin at pos, the result is the code
unit at pos.
This method performs the following steps when called:
This method is intentionally generic; it does not require that its
this value be a String object. Therefore it can be transferred to
other kinds of objects for use as a method.
22.1.3.5 String.prototype.concat ( ...args )
Note 1
When this method is called it returns the String value consisting of the code units
of the this value (converted to a String) followed by the code
units of each of the arguments converted to a String. The result is a String
value, not a String object.
This method performs the following steps when called:
This method is intentionally generic; it does not require that its
this value be a String object. Therefore it can be transferred to
other kinds of objects for use as a method.
22.1.3.6 String.prototype.constructor
The initial value of String.prototype.constructor is %String%.
If endPosition is undefined, let pos be
len; else let pos be ? ToIntegerOrInfinity(endPosition).
Let end be the result of clampingpos between 0 and
len.
Let searchLength be the length of searchStr.
If searchLength = 0, return true.
Let start be end - searchLength.
If start < 0, return false.
Let substring be the substring of S from
start to end.
If substring is searchStr, return true.
Return false.
Note 1
This method returns true if the sequence of code units of
searchString converted to a String is the same as the corresponding code
units of this object (converted to a String) starting at endPosition -
length(this). Otherwise it returns false.
Note 2
Throwing an exception if the first argument is a RegExp is specified in order to
allow future editions to define extensions that allow such argument values.
Note 3
This method is intentionally generic; it does not require that its
this value be a String object. Therefore, it can be transferred
to other kinds of objects for use as a method.
22.1.3.8 String.prototype.includes ( searchString [ ,
position ] )
This method performs the following steps when called:
If searchString appears as a substring of the
result of converting this object to a String, at one or more indices that are
greater than or equal to position, this function returns
true; otherwise, it returns false. If
position is undefined, 0 is assumed, so as to search
all of the String.
Note 2
Throwing an exception if the first argument is a RegExp is specified in order to
allow future editions to define extensions that allow such argument values.
Note 3
This method is intentionally generic; it does not require that its
this value be a String object. Therefore, it can be transferred
to other kinds of objects for use as a method.
22.1.3.9 String.prototype.indexOf ( searchString [ ,
position ] )
Note 1
If searchString appears as a substring of the
result of converting this object to a String, at one or more indices that are
greater than or equal to position, then the smallest such index is
returned; otherwise, -1𝔽 is returned. If
position is undefined,
+0𝔽 is assumed, so as to search all of the String.
This method performs the following steps when called:
This method is intentionally generic; it does not require that its
this value be a String object. Therefore, it can be transferred
to other kinds of objects for use as a method.
22.1.3.10 String.prototype.isWellFormed ( )
This method performs the following steps when called:
22.1.3.11 String.prototype.lastIndexOf ( searchString
[ , position ] )
Note 1
If searchString appears as a substring of the
result of converting this object to a String at one or more indices that are smaller
than or equal to position, then the greatest such index is returned;
otherwise, -1𝔽 is returned. If position is
undefined, the length of the String value is assumed, so as to
search all of the String.
This method performs the following steps when called:
This method is intentionally generic; it does not require that its
this value be a String object. Therefore, it can be transferred
to other kinds of objects for use as a method.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must
implement this method as specified in the ECMA-402 specification. If an ECMAScript
implementation does not include the ECMA-402 API the following specification of this method
is used:
This method returns a Number other than NaN representing the result of an
implementation-defined
locale-sensitive String comparison of the this value (converted to a
String S) with that (converted to a String thatValue). The
result is intended to correspond with a sort order of String values according to
conventions of the host environment's current locale, and will
be negative when S is ordered before thatValue, positive when
S is ordered after thatValue, and zero in all other cases
(representing no relative ordering between S and thatValue).
Before performing the comparisons, this method performs the following steps to prepare the
Strings:
The meaning of the optional second and third parameters to this method are defined in the
ECMA-402 specification; implementations that do not include ECMA-402 support must not assign
any other interpretation to those parameter positions.
The actual return values are implementation-defined to permit
encoding additional information in them, but this method, when considered as a method of two
arguments, is required to be a consistent comparator defining a total
ordering on the set of all Strings. This method is also required to recognize and honour
canonical equivalence according to the Unicode Standard, including returning
+0𝔽 when comparing distinguishable Strings that are
canonically equivalent.
Note 1
This method itself is not directly suitable as an argument to
Array.prototype.sort because the latter requires a function of two
arguments.
Note 2
This method may rely on whatever language- and/or locale-sensitive comparison
functionality is available to the ECMAScript environment from the host
environment, and is intended to compare according to the
conventions of the host environment's current locale.
However, regardless of comparison capabilities, this method must recognize and
honour canonical equivalence according to the Unicode Standard—for example, the
following comparisons must all return +0𝔽:
// Å ANGSTROM SIGN vs.// Å LATIN CAPITAL LETTER A + COMBINING RING ABOVE"\u212B".localeCompare("A\u030A")
// Ω OHM SIGN vs.// Ω GREEK CAPITAL LETTER OMEGA"\u2126".localeCompare("\u03A9")
// ṩ LATIN SMALL LETTER S WITH DOT BELOW AND DOT ABOVE vs.// ṩ LATIN SMALL LETTER S + COMBINING DOT ABOVE + COMBINING DOT BELOW"\u1E69".localeCompare("s\u0307\u0323")
// ḍ̇ LATIN SMALL LETTER D WITH DOT ABOVE + COMBINING DOT BELOW vs.// ḍ̇ LATIN SMALL LETTER D WITH DOT BELOW + COMBINING DOT ABOVE"\u1E0B\u0323".localeCompare("\u1E0D\u0307")
// 가 HANGUL CHOSEONG KIYEOK + HANGUL JUNGSEONG A vs.// 가 HANGUL SYLLABLE GA"\u1100\u1161".localeCompare("\uAC00")
It is recommended that this method should not honour Unicode compatibility
equivalents or compatibility decompositions as defined in the Unicode Standard,
chapter 3, section 3.7.
Note 3
This method is intentionally generic; it does not require that its
this value be a String object. Therefore, it can be transferred
to other kinds of objects for use as a method.
22.1.3.13 String.prototype.match ( regexp )
This method performs the following steps when called:
This method is intentionally generic; it does not require that its
this value be a String object. Therefore, it can be transferred
to other kinds of objects for use as a method.
22.1.3.14 String.prototype.matchAll ( regexp )
This method performs a regular expression match of the String representing the
this value against regexp and returns an iterator that yields match results.
Each match result is an Array containing the matched portion of the String as the first
element, followed by the portions matched by any capturing groups. If the regular expression
never matches, the returned iterator does not yield any match
results.
This method is intentionally generic, it does not require that
its this value be a String object. Therefore, it can be transferred
to other kinds of objects for use as a method.
Note 2
Similarly to String.prototype.split,
String.prototype.matchAll is designed to typically act without mutating its
inputs.
22.1.3.15 String.prototype.normalize ( [ form ] )
This method performs the following steps when called:
This method is intentionally generic; it does not require that its
this value be a String object. Therefore it can be transferred to
other kinds of objects for use as a method.
The abstract operation StringPad takes arguments S (a String),
maxLength (a non-negative integer), fillString (a String), and
placement (start or end) and
returns a String. It performs the following steps when called:
Let stringLength be the length of S.
If maxLength ≤ stringLength, return S.
If fillString is the empty String, return S.
Let fillLen be maxLength - stringLength.
Let truncatedStringFiller be the String value consisting of repeated
concatenations of fillString truncated to length fillLen.
If placement is start, return the string-concatenation of
truncatedStringFiller and S.
The argument maxLength will be clamped such that it can be no smaller
than the length of S.
Note 2
The argument fillString defaults to " " (the String
value consisting of the code unit 0x0020 SPACE).
22.1.3.17.3 ToZeroPaddedDecimalString ( n,
minLength )
The abstract operation ToZeroPaddedDecimalString takes arguments n (a
non-negative integer) and minLength (a non-negative
integer) and
returns a String. It performs the following steps when called:
Let S be the String representation of n, formatted as a
decimal number.
Return the String value that is made from n copies of S
appended together.
Note 1
This method creates the String value consisting of the code units of the
this value (converted to String) repeated count times.
Note 2
This method is intentionally generic; it does not require that its
this value be a String object. Therefore, it can be transferred
to other kinds of objects for use as a method.
This method is intentionally generic; it does not require that its
this value be a String object. Therefore, it can be transferred
to other kinds of objects for use as a method.
The abstract operation GetSubstitution takes arguments matched (a String),
str (a String), position (a non-negative integer), captures (a
List of either
Strings or undefined), namedCaptures (an Object or
undefined), and replacementTemplate (a String) and returns
either a normal completion
containing a String or a throw
completion. For the purposes of this abstract operation, a
decimal digit is a code unit in the inclusive interval from
0x0030 (DIGIT ZERO) to 0x0039 (DIGIT NINE). It performs the following steps when called:
Repeat, while templateRemainder is not the empty String,
NOTE: The following steps isolate
ref (a prefix of templateRemainder), determine
refReplacement (its replacement), and then append that
replacement to result.
If templateRemainder starts with "$$",
then
Let ref be "$$".
Let refReplacement be "$".
Else if templateRemainder starts with
"$`", then
Let ref be "$`".
Let refReplacement be the substring of
str from 0 to position.
Else if templateRemainder starts with
"$&", then
Let ref be "$&".
Let refReplacement be matched.
Else if templateRemainder starts with "$'"
(0x0024 (DOLLAR SIGN) followed by 0x0027 (APOSTROPHE)), then
Let ref be "$'".
Let matchLength be the length of matched.
Let tailPos be position +
matchLength.
Let refReplacement be the substring of
str from min(tailPos,
stringLength).
NOTE: tailPos can exceed stringLength only
if this abstract operation was invoked by a call to the
intrinsic %Symbol.replace%
method of %RegExp.prototype%
on an object whose "exec" property is not the
intrinsic %RegExp.prototype.exec%.
Else if templateRemainder starts with "$"
followed by 1 or more decimal digits, then
If templateRemainder starts with
"$" followed by 2 or more decimal digits, let
digitCount be 2; otherwise let digitCount
be 1.
Let digits be the substring of
templateRemainder from 1 to 1 +
digitCount.
Let captureLen be the number of elements in
captures.
If index > captureLen and
digitCount = 2, then
NOTE: When a two-digit replacement pattern specifies an
index exceeding the count of capturing groups, it is
treated as a one-digit replacement pattern followed by a
literal digit.
Set digitCount to 1.
Set digits to the substring of
digits from 0 to 1.
This method is intentionally generic; it does not require that its
this value be a String object. Therefore, it can be transferred
to other kinds of objects for use as a method.
22.1.3.22 String.prototype.slice ( start,
end )
This method returns a substring of the result of converting this
object to a String, starting from index start and running to, but not including,
index end (or through the end of the String if end is
undefined). If start is negative, it is treated as sourceLength + start where
sourceLength is the length of the String. If end is negative, it is
treated as sourceLength + end where
sourceLength is the length of the String. The result is a String value,
not a String object.
This method is intentionally generic; it does not require that its
this value be a String object. Therefore it can be transferred to
other kinds of objects for use as a method.
This method returns an Array into which substrings of the result of converting this object to
a String have been stored. The substrings are determined by searching from left to right for
occurrences of separator; these occurrences are not part of any String in the
returned array, but serve to divide up the String value. The value of separator
may be a String of any length or it may be an object, such as a RegExp, that has a %Symbol.split% method.
The value of separator may be an empty String. In this case,
separator does not match the empty substring
at the beginning or end of the input String, nor does it match the empty
substring at the end of the previous separator match. If
separator is the empty String, the String is split up into individual
code unit elements; the length of the result array equals the length of the String,
and each substring contains one code unit.
If the this value is (or converts to) the empty String, the result
depends on whether separator can match the empty String. If it can, the
result array contains no elements. Otherwise, the result array contains one element,
which is the empty String.
If separator is undefined, then the result array
contains just one String, which is the this value (converted to a
String). If limit is not undefined, then the output
array is truncated so that it contains no more than limit elements.
Note 2
This method is intentionally generic; it does not require that its
this value be a String object. Therefore, it can be transferred
to other kinds of objects for use as a method.
22.1.3.24 String.prototype.startsWith ( searchString
[ , position ] )
This method performs the following steps when called:
If position is undefined, let pos be 0;
else let pos be ? ToIntegerOrInfinity(position).
Let start be the result of clampingpos between 0 and
len.
Let searchLength be the length of searchStr.
If searchLength = 0, return true.
Let end be start + searchLength.
If end > len, return false.
Let substring be the substring of S from
start to end.
If substring is searchStr, return true.
Return false.
Note 1
This method returns true if the sequence of code units of
searchString converted to a String is the same as the corresponding code
units of this object (converted to a String) starting at index position.
Otherwise it returns false.
Note 2
Throwing an exception if the first argument is a RegExp is specified in order to
allow future editions to define extensions that allow such argument values.
Note 3
This method is intentionally generic; it does not require that its
this value be a String object. Therefore, it can be transferred
to other kinds of objects for use as a method.
22.1.3.25 String.prototype.substring ( start,
end )
This method returns a substring of the result of converting this
object to a String, starting from index start and running to, but not including,
index end of the String (or through the end of the String if end is
undefined). The result is a String value,
not a String object.
If either argument is NaN or negative, it is replaced with zero; if either
argument is strictly greater than the length of the String, it is replaced with the length
of the String.
If start is strictly greater than end, they are swapped.
This method is intentionally generic; it does not require that its
this value be a String object. Therefore, it can be transferred
to other kinds of objects for use as a method.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must
implement this method as specified in the ECMA-402 specification. If an ECMAScript
implementation does not include the ECMA-402 API the following specification of this method
is used:
This method interprets a String value as a sequence of UTF-16 encoded code points, as
described in 6.1.4.
It works exactly the same as toLowerCase except that it is intended to yield a
locale-sensitive result corresponding with conventions of the host
environment's current locale. There will only be a difference in the
few cases (such as Turkish) where the rules for that language conflict with the regular
Unicode case mappings.
The meaning of the optional parameters to this method are defined in the ECMA-402
specification; implementations that do not include ECMA-402 support must not use those
parameter positions for anything else.
Note
This method is intentionally generic; it does not require that its
this value be a String object. Therefore, it can be transferred
to other kinds of objects for use as a method.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must
implement this method as specified in the ECMA-402 specification. If an ECMAScript
implementation does not include the ECMA-402 API the following specification of this method
is used:
This method interprets a String value as a sequence of UTF-16 encoded code points, as
described in 6.1.4.
It works exactly the same as toUpperCase except that it is intended to yield a
locale-sensitive result corresponding with conventions of the host
environment's current locale. There will only be a difference in the
few cases (such as Turkish) where the rules for that language conflict with the regular
Unicode case mappings.
The meaning of the optional parameters to this method are defined in the ECMA-402
specification; implementations that do not include ECMA-402 support must not use those
parameter positions for anything else.
Note
This method is intentionally generic; it does not require that its
this value be a String object. Therefore, it can be transferred
to other kinds of objects for use as a method.
22.1.3.28 String.prototype.toLowerCase ( )
This method interprets a String value as a sequence of UTF-16 encoded code points, as
described in 6.1.4.
The result must be derived according to the locale-insensitive case mappings in the Unicode
Character Database (this explicitly includes not only the file UnicodeData.txt,
but also all locale-insensitive mappings in the file SpecialCasing.txt
that accompanies it).
Note 1
The case mapping of some code points may produce multiple code points. In this case
the result String may not be the same length as the source String. Because both
toUpperCase and toLowerCase have context-sensitive
behaviour, the methods are not symmetrical. In other words,
s.toUpperCase().toLowerCase() is not necessarily equal to
s.toLowerCase().
Note 2
This method is intentionally generic; it does not require that its
this value be a String object. Therefore, it can be transferred
to other kinds of objects for use as a method.
22.1.3.29 String.prototype.toString ( )
This method performs the following steps when called:
For a String object, this method happens to return the same thing as the
valueOf method.
22.1.3.30 String.prototype.toUpperCase ( )
This method interprets a String value as a sequence of UTF-16 encoded code points, as
described in 6.1.4.
It behaves in exactly the same way as String.prototype.toLowerCase, except that
the String is mapped using the toUppercase algorithm of the Unicode Default Case Conversion.
Note
This method is intentionally generic; it does not require that its
this value be a String object. Therefore, it can be transferred
to other kinds of objects for use as a method.
This method is intentionally generic; it does not require that its
this value be a String object. Therefore, it can be transferred
to other kinds of objects for use as a method.
22.1.3.32.1 TrimString ( string, where
)
The abstract operation TrimString takes arguments string (an ECMAScript language value)
and where (start, end, or
start+end) and returns either a normal completion
containing a String or a throw
completion. It interprets string as a sequence of
UTF-16 encoded code points, as described in 6.1.4. It
performs the following steps when called:
Let T be the String value that is a copy of S with
both leading and trailing white space removed.
Return T.
The definition of white space is the union of WhiteSpace and LineTerminator. When determining
whether a Unicode code point is in Unicode general category “Space_Separator” (“Zs”),
code unit sequences are interpreted as UTF-16 encoded code point sequences as specified
in 6.1.4.
22.1.3.33 String.prototype.trimEnd ( )
This method interprets a String value as a sequence of UTF-16 encoded code points, as
described in 6.1.4.
This method is intentionally generic; it does not require that its
this value be a String object. Therefore, it can be transferred
to other kinds of objects for use as a method.
22.1.3.34 String.prototype.trimStart ( )
This method interprets a String value as a sequence of UTF-16 encoded code points, as
described in 6.1.4.
This method is intentionally generic; it does not require that its
this value be a String object. Therefore, it can be transferred
to other kinds of objects for use as a method.
22.1.3.35 String.prototype.valueOf ( )
This method performs the following steps when called:
The value of the "name" property of this method is
"[Symbol.iterator]".
22.1.4 Properties of String Instances
String instances are String exotic objects and have the internal
methods specified for such objects. String instances inherit properties from the String prototype
object. String instances also have a [[StringData]] internal slot. The [[StringData]] internal slot is the String value represented by this
String object.
String instances have a "length" property, and a set of enumerable properties
with integer-indexed names.
22.1.4.1 length
The number of elements in the String value represented by this String object.
Once a String object is initialized, this property is unchanging. It has the attributes {
[[Writable]]: false, [[Enumerable]]: false, [[Configurable]]: false }.
22.1.5 String Iterator Objects
A String Iterator is an object that represents a specific iteration over
some specific String instance object. There is not a named constructor for String Iterator
objects. Instead, String Iterator objects are created by calling certain methods of String
instance objects.
The initial value of the %Symbol.toStringTag% property is
the String value "String Iterator".
This property has the attributes { [[Writable]]:
false, [[Enumerable]]:
false, [[Configurable]]:
true }.
22.2 RegExp (Regular Expression) Objects
A RegExp object contains a regular expression and the associated flags.
Note
The form and functionality of regular expressions is modelled after the regular expression
facility in the Perl 5 programming language.
22.2.1 Patterns
The RegExp constructor applies the following grammar to the
input pattern String. An error occurs if the grammar cannot interpret the String as an expansion
of Pattern.
The abstract operation CountLeftCapturingParensWithin takes argument node (a
Parse Node) and returns a non-negative
integer. It
returns the number of left-capturing parentheses in node. A left-capturing parenthesis is
any ( pattern character that is matched by the ( terminal of the
Atom::(GroupSpecifieroptDisjunction) production.
The abstract operation CountLeftCapturingParensBefore takes argument node (a
Parse Node) and returns a non-negative
integer. It
returns the number of left-capturing
parentheses within the enclosing pattern that occur to the left of
node.
22.2.1.4 Static Semantics: MightBothParticipate ( x,
y )
The abstract operation MightBothParticipate takes arguments x (a Parse
Node) and y (a Parse Node) and returns
a Boolean. It performs the following steps when called:
The abstract operation GroupSpecifiersThatMatch takes argument thisGroupName (a
GroupNameParse
Node) and returns a List of GroupSpecifierParse
Nodes. It performs the following steps when called:
The syntax-directed
operation RegExpIdentifierCodePoints takes no arguments and returns a
List of code points.
It is defined piecewise over the following productions:
The syntax-directed
operation RegExpIdentifierCodePoint takes no arguments and returns a
code point. It is defined piecewise over the following productions:
A regular expression pattern is converted into an Abstract Closure using the
process described below. An implementation is encouraged to use more efficient algorithms than
the ones listed below, as long as the results are the same. The Abstract
Closure is used as the value of a RegExp object's [[RegExpMatcher]] internal slot.
A Pattern is a BMP pattern if its
associated flags contain neither a u nor a v. Otherwise, it is a
Unicode pattern. A BMP pattern matches against a String interpreted as consisting of a sequence
of 16-bit values that are Unicode code points in the range of the Basic Multilingual Plane. A
Unicode pattern matches against a String interpreted as consisting of Unicode code points
encoded using UTF-16. In the context of describing the behaviour of a BMP pattern “character”
means a single 16-bit Unicode BMP code point. In the context of describing the behaviour of a
Unicode pattern “character” means a UTF-16 encoded code point (6.1.4). In either
context, “character value” means the numeric value of the corresponding non-encoded code point.
The syntax and semantics of Pattern
is defined as if the source text for the Pattern was a List of SourceCharacter values where
each SourceCharacter
corresponds to a Unicode code point. If a BMP pattern contains a non-BMP SourceCharacter the entire
pattern is encoded using UTF-16 and the individual code units of that encoding are used as the
elements of the List.
Note
For example, consider a pattern expressed in source text as the single non-BMP character
U+1D11E (MUSICAL SYMBOL G CLEF). Interpreted as a Unicode pattern, it would be a single
element (character) List consisting of
the single code point U+1D11E. However, interpreted as a BMP pattern, it is first UTF-16
encoded to produce a two element List consisting of
the code units 0xD834 and 0xDD1E.
Patterns are passed to the RegExp constructor as ECMAScript String values in
which non-BMP characters are UTF-16 encoded. For example, the single character MUSICAL
SYMBOL G CLEF pattern, expressed as a String value, is a String of
length 2 whose elements were the code units 0xD834 and 0xDD1E. So no further translation
of the string would be necessary to process it as a BMP pattern consisting of two
pattern characters. However, to process it as a Unicode pattern UTF16SurrogatePairToCodePoint
must be used in producing a List whose sole
element is a single pattern character, the code point U+1D11E.
An implementation may not actually perform such translations to or from UTF-16, but the
semantics of this specification requires that the result of pattern matching be as if
such translations were performed.
22.2.2.1 Notation
The descriptions below use the following internal data structures:
A CharSetElement is one of the two following entities:
If rer.[[UnicodeSets]] is
false, then a CharSetElement is a character in the sense of
the Pattern Semantics above.
If rer.[[UnicodeSets]] is
true, then a CharSetElement is a sequence whose elements are
characters in the sense of the Pattern Semantics above. This includes the empty
sequence, sequences of one character, and sequences of more than one character.
For convenience, when working with CharSetElements of this kind, an individual
character is treated interchangeably with a sequence of one character.
A CharSet is a
mathematical set of CharSetElements.
A CaptureRange is a Record { [[StartIndex]], [[EndIndex]] } that
represents the range of characters included in a capture, where [[StartIndex]] is an integer representing the start
index (inclusive) of the range within Input, and [[EndIndex]] is an integer representing the end index (exclusive) of
the range within Input. For any CaptureRange, these
indices must satisfy the invariant that [[StartIndex]] ≤ [[EndIndex]].
A MatchState is a Record { [[Input]], [[EndIndex]], [[Captures]] } where [[Input]] is a
List of characters
representing the String being matched, [[EndIndex]] is an
integer, and
[[Captures]] is a List of values,
one for each left-capturing
parenthesis in the pattern. MatchStates are used to
represent partial match states in the regular expression matching algorithms. The [[EndIndex]] is one plus the index of the last input character
matched so far by the pattern, while [[Captures]] holds the
results of capturing parentheses. The nth element of [[Captures]] is either a CaptureRange
representing the range of characters captured by the nth set of
capturing parentheses, or undefined if the nth
set of capturing parentheses hasn't been reached yet. Due to backtracking, many
MatchStates may be in use at any time
during the matching process.
A MatcherContinuation is an Abstract Closure that
takes one MatchState argument and returns either
a MatchState or
failure. The MatcherContinuation attempts
to match the remaining portion (specified by the closure's captured values) of the
pattern against Input, starting at the intermediate state given by its
MatchState argument. If the match
succeeds, the MatcherContinuation returns
the final MatchState that it reached; if the
match fails, the MatcherContinuation returns
failure.
A Matcher is an
Abstract Closure that takes two
arguments—a MatchState and a MatcherContinuation—and
returns either a MatchState or
failure. A Matcher attempts to match a middle
subpattern (specified by the closure's captured values) of the pattern against the
MatchState's [[Input]], starting at the intermediate state given by its
MatchState argument. The MatcherContinuation argument
should be a closure that matches the rest of the pattern. After matching the subpattern
of a pattern to obtain a new MatchState, the Matcher then calls MatcherContinuation on that
new MatchState to test if the rest of the
pattern can match as well. If it can, the Matcher returns the
MatchState returned by MatcherContinuation; if not,
the Matcher may try different choices at its
choice points, repeatedly calling MatcherContinuation until it
either succeeds or all possibilities have been exhausted.
22.2.2.1.1 RegExp Records
A RegExp Record is a Record value used
to store information about a RegExp that is needed during compilation and possibly
during matching.
Let cap be a List
of rer.[[CapturingGroupsCount]]undefined values, indexed 1 through rer.[[CapturingGroupsCount]].
Let x be the MatchState
{ [[Input]]: Input, [[EndIndex]]: index, [[Captures]]: cap }.
Return m(x, c).
Note
A Pattern compiles to an Abstract Closure value.
RegExpBuiltinExec can then
apply this procedure to a List of
characters and an offset within that List to
determine whether the pattern would match starting at exactly that offset within the
List, and, if
it does match, what the values of the capturing parentheses would be. The algorithms
in 22.2.2 are designed so that
compiling a pattern may throw a SyntaxError exception; on the
other hand, once the pattern is successfully compiled, applying the resulting
Abstract Closure to find a match
in a List of
characters cannot throw an exception (except for any implementation-defined
exceptions that can occur anywhere such as out-of-memory).
The | regular expression operator separates two alternatives. The
pattern first tries to match the left Alternative (followed by the sequel of
the regular expression); if it fails, it tries to match the right Disjunction (followed
by the sequel of the regular expression). If the left Alternative, the right Disjunction, and the
sequel all have choice points, all choices in the sequel are tried before moving on
to the next choice in the left Alternative. If choices in the left
Alternative are
exhausted, the right Disjunction is tried instead of the
left Alternative.
Any capturing parentheses inside a portion of the pattern skipped by |
produce undefined values instead of Strings. Thus, for example,
Consecutive Terms try to
simultaneously match consecutive portions of Input. When
direction is forward, if the left Alternative, the right
Term, and the sequel of
the regular expression all have choice points, all choices in the sequel are tried
before moving on to the next choice in the right Term, and all choices in the right Term are tried before moving
on to the next choice in the left Alternative. When direction
is backward, the evaluation order of Alternative and Term are reversed.
The abstract operation RepeatMatcher takes arguments m (a Matcher), min (a non-negative
integer),
max (a non-negative integer or +∞), greedy (a Boolean),
x (a MatchState), c (a MatcherContinuation),
parenIndex (a non-negative integer), and parenCount (a
non-negative integer) and returns either a MatchState or
failure. It performs the following steps when called:
If max = 0, return c(x).
Let d be a new MatcherContinuation
with parameters (y) that captures m, min,
max, greedy, x, c,
parenIndex, and parenCount and performs the following
steps when called:
If min = 0 and y.[[EndIndex]] = x.[[EndIndex]], return
failure.
If min = 0, let min2 be 0; otherwise let
min2 be min - 1.
If max = +∞, let max2 be +∞; otherwise let
max2 be max - 1.
Return RepeatMatcher(m,
min2, max2, greedy, y,
c, parenIndex, parenCount).
Let cap be a copy of x.[[Captures]].
For each integerk in
the inclusive interval from
parenIndex + 1 to parenIndex + parenCount, set
cap[k] to undefined.
Let Input be x.[[Input]].
Let e be x.[[EndIndex]].
Let xr be the MatchState { [[Input]]: Input, [[EndIndex]]: e, [[Captures]]: cap }.
If min ≠ 0, return m(xr, d).
If greedy is false, then
Let z be c(x).
If z is not failure, return
z.
Return m(xr, d).
Let z be m(xr, d).
If z is not failure, return z.
Return c(x).
Note 1
An Atom followed by a
Quantifier is
repeated the number of times specified by the Quantifier. A Quantifier can be
non-greedy, in which case the Atom pattern is repeated as few times as
possible while still matching the sequel, or it can be greedy, in which case the
Atom pattern is
repeated as many times as possible while still matching the sequel. The Atom pattern is repeated
rather than the input character sequence that it matches, so different
repetitions of the Atom can match different input
substrings.
Note 2
If the Atom and the
sequel of the regular expression all have choice points, the Atom is first matched as
many (or as few, if non-greedy) times as possible. All choices in the sequel are
tried before moving on to the next choice in the last repetition of Atom. All choices in the
last (nth) repetition of Atom are tried before moving on to the
next choice in the next-to-last (n - 1)st repetition of Atom; at which point it
may turn out that more or fewer repetitions of Atom are now possible; these are
exhausted (again, starting with either as few or as many as possible) before
moving on to the next choice in the (n - 1)st repetition of Atom and so on.
Compare
/a[a-z]{2,4}/.exec("abcdefghi")
which returns "abcde" with
/a[a-z]{2,4}?/.exec("abcdefghi")
which returns "abc".
Consider also
/(aa|aabaac|ba|b|c)*/.exec("aabaac")
which, by the choice point ordering above, returns the array
["aaba", "ba"]
and not any of:
["aabaac", "aabaac"]
["aabaac", "c"]
The above ordering of choice points can be used to write a regular expression
that calculates the greatest common divisor of two numbers (represented in unary
notation). The following example calculates the gcd of 10 and 15:
Step 4 of the
RepeatMatcher clears Atom's captures each time Atom is repeated. We can
see its behaviour in the regular expression
/(z)((a+)?(b+)?(c))*/.exec("zaacbbbcac")
which returns the array
["zaacbbbcac", "z", "ac", "a", undefined, "c"]
and not
["zaacbbbcac", "z", "ac", "a", "bbb", "c"]
because each iteration of the outermost * clears all captured
Strings contained in the quantified Atom, which in this case includes capture
Strings numbered 2, 3, 4, and 5.
Note 4
Step 2.b of the RepeatMatcher
states that once the minimum number of repetitions has been satisfied, any more
expansions of Atom
that match the empty character sequence are not considered for further
repetitions. This prevents the regular expression engine from falling into an
infinite loop on patterns such as:
/(a*)*/.exec("b")
or the slightly more complicated:
/(a*)b\1+/.exec("baaaac")
which returns the array
["b", ""]
22.2.2.3.2 EmptyMatcher ( )
The abstract operation EmptyMatcher takes no arguments and returns a Matcher. It performs the following steps
when called:
Return a new Matcher with parameters
(x, c) that captures nothing and performs the following
steps when called:
The abstract operation MatchTwoAlternatives takes arguments m1 (a Matcher) and m2 (a Matcher) and returns a Matcher. It performs the following steps
when called:
Return a new Matcher with parameters
(x, c) that captures m1 and m2 and
performs the following steps when called:
The abstract operation MatchSequence takes arguments m1 (a Matcher), m2 (a Matcher), and direction
(forward or backward) and returns a
Matcher. It performs the following steps
when called:
If direction is forward, then
Return a new Matcher with parameters
(x, c) that captures m1 and
m2 and performs the following steps when called:
If e = 0, or if rer.[[Multiline]] is true and the
character Input[e - 1] is matched by LineTerminator, then
Return c(x).
Return failure.
Note 2
Even when the y flag is used with a pattern, ^ always
matches only at the beginning of Input, or (if rer.[[Multiline]] is true) at the beginning
of a line.
Let z be the MatchState
{ [[Input]]: Input, [[EndIndex]]: xe, [[Captures]]: cap }.
Return c(z).
Note 3
The form (?=Disjunction) specifies a
zero-width positive lookahead. In order for it to succeed, the pattern inside
Disjunction must
match at the current position, but the current position is not advanced before
matching the sequel. If Disjunction can match at the current
position in several ways, only the first one is tried. Unlike other regular
expression operators, there is no backtracking into a (?= form (this
unusual behaviour is inherited from Perl). This only matters when the Disjunction contains
capturing parentheses and the sequel of the pattern contains backreferences to those
captures.
For example,
/(?=(a+))/.exec("baaabac")
matches the empty String immediately after the first b and therefore
returns the array:
["", "aaa"]
To illustrate the lack of backtracking into the lookahead, consider:
The form (?!Disjunction) specifies a
zero-width negative lookahead. In order for it to succeed, the pattern inside
Disjunction must
fail to match at the current position. The current position is not advanced before
matching the sequel. Disjunction can contain capturing
parentheses, but backreferences to them only make sense from within Disjunction itself.
Backreferences to these capturing parentheses from elsewhere in the pattern always
return undefined because the negative lookahead must fail for the
pattern to succeed. For example,
/(.*?)a(?!(a+)b\2c)\2(.*)/.exec("baaabaac")
looks for an a not immediately followed by some positive number n of
a's, a b, another n a's (specified by the
first \2) and a c. The second \2 is outside
the negative lookahead, so it matches against undefined and
therefore always succeeds. The whole expression returns the array:
The abstract operation IsWordChar takes arguments rer (a RegExp
Record), Input (a List of
characters), and e (an integer) and returns a Boolean. It performs the
following steps when called:
Let InputLength be the number of elements in Input.
The syntax-directed
operation CompileQuantifier takes no arguments and returns a
Record with fields
[[Min]] (a non-negative integer), [[Max]] (a non-negative integer or +∞), and [[Greedy]] (a Boolean). It is defined piecewise over the following
productions:
The syntax-directed
operation CompileQuantifierPrefix takes no arguments and returns a
Record with fields
[[Min]] (a non-negative integer) and [[Max]] (a non-negative integer or +∞). It is defined piecewise over the
following productions:
If rer.[[UnicodeSets]] is
false, or if every CharSetElement of
cs consists of a single character (including if cs is empty),
return CharacterSetMatcher(rer,
cs, cc.[[Invert]],
direction).
Let r be the CaptureRange
{ [[StartIndex]]: ye,
[[EndIndex]]: xe }.
Set cap[parenIndex + 1] to r.
Let z be the MatchState { [[Input]]: Input, [[EndIndex]]: ye, [[Captures]]: cap }.
Return c(z).
Return m(x, d).
Note 2
Parentheses of the form (Disjunction) serve both
to group the components of the Disjunction pattern together and to
save the result of the match. The result can be used either in a backreference
(\ followed by a non-zero decimal number), referenced in a replace
String, or returned as part of an array from the regular expression matching
Abstract Closure. To inhibit the
capturing behaviour of parentheses, use the form (?:Disjunction) instead.
An escape sequence of the form \ followed by a non-zero decimal number
n matches the result of the nth set of capturing
parentheses (22.2.2.1). It is an error if the
regular expression has fewer than n capturing parentheses. If the regular
expression has n or more capturing parentheses but the
nth one is undefined because it has not
captured anything, then the backreference always succeeds.
If rer.[[UnicodeSets]] is
false, or if every CharSetElement of
cs consists of a single character (including if cs is empty),
return CharacterSetMatcher(rer,
cs, false, direction).
22.2.2.7.1 CharacterSetMatcher ( rer,
A, invert, direction )
The abstract operation CharacterSetMatcher takes arguments rer (a RegExp
Record), A (a CharSet),
invert (a Boolean), and direction (forward
or backward) and returns a Matcher. It performs the
following steps when called:
If there exists a CharSetElement in
A containing exactly one character a such that
Canonicalize(rer,
a) is cc, let found be
true; otherwise let found be
false.
If invert is false and found is
false, return failure.
If invert is true and found is
true, return failure.
Let cap be x.[[Captures]].
Let y be the MatchState { [[Input]]: Input, [[EndIndex]]: f, [[Captures]]: cap }.
Return c(y).
22.2.2.7.2 BackreferenceMatcher ( rer,
ns, direction )
The abstract operation BackreferenceMatcher takes arguments rer (a RegExp
Record), ns (a List of positive
integers),
and direction (forward or
backward) and returns a Matcher. It performs the
following steps when called:
Return a new Matcher with parameters
(x, c) that captures rer, ns, and
direction and performs the following steps when called:
If there exists an integeri in the
interval from 0 (inclusive) to
len (exclusive) such that Canonicalize(rer,
Input[rs + i]) is not Canonicalize(rer,
Input[g + i]), return
failure.
Let y be the MatchState { [[Input]]: Input, [[EndIndex]]: f, [[Captures]]: cap }.
Return c(y).
22.2.2.7.3 Canonicalize ( rer, ch )
The abstract operation Canonicalize takes arguments rer (a RegExp
Record) and ch (a character) and returns a character.
It performs the following steps when called:
If the file CaseFolding.txt
of the Unicode Character Database provides a simple or common case
folding mapping for ch, return the result of applying that
mapping to ch.
If the numeric value of ch ≥ 128 and the numeric value of
cu < 128, return ch.
Return cu.
Note
In case-insignificant matches when HasEitherUnicodeFlag(rer)
is true, all characters are implicitly case-folded using the
simple mapping provided by the Unicode Standard immediately before they are
compared. The simple mapping always maps to a single code point, so it does not
map, for example, ß (U+00DF LATIN SMALL LETTER SHARP S) to
ss or SS. It may however map code points outside the
Basic Latin block to code points within it—for example, ſ (U+017F
LATIN SMALL LETTER LONG S) case-folds to s (U+0073 LATIN SMALL
LETTER S) and K (U+212A KELVIN SIGN) case-folds to k
(U+006B LATIN SMALL LETTER K). Strings containing those code points are matched
by regular expressions such as /[a-z]/ui.
In case-insignificant matches when HasEitherUnicodeFlag(rer)
is false, the mapping is based on Unicode Default Case
Conversion algorithm toUppercase rather than toCasefold, which results in some
subtle differences. For example, Ω (U+2126 OHM SIGN) is mapped by
toUppercase to itself but by toCasefold to ω (U+03C9 GREEK SMALL
LETTER OMEGA) along with Ω (U+03A9 GREEK CAPITAL LETTER OMEGA), so
"\u2126" is matched by /[ω]/ui and
/[\u03A9]/ui but not by /[ω]/i or
/[\u03A9]/i. Also, no code point outside the Basic Latin block is
mapped to a code point within it, so strings such as "\u017F
ſ" and "\u212A K" are not matched by
/[a-z]/i.
22.2.2.7.4 UpdateModifiers ( rer, add,
remove )
The abstract operation UpdateModifiers takes arguments rer (a RegExp
Record), add (a String), and remove (a
String) and returns a RegExp Record. It performs the
following steps when called:
Assert: add and
remove have no elements in common.
Let ignoreCase be rer.[[IgnoreCase]].
Let multiline be rer.[[Multiline]].
Let dotAll be rer.[[DotAll]].
Let unicode be rer.[[Unicode]].
Let unicodeSets be rer.[[UnicodeSets]].
Let capturingGroupsCount be rer.[[CapturingGroupsCount]].
If remove contains "i", set ignoreCase
to false.
Else if add contains "i", set
ignoreCase to true.
If remove contains "m", set multiline
to false.
Else if add contains "m", set multiline
to true.
If remove contains "s", set dotAll to
false.
Else if add contains "s", set dotAll to
true.
Return the RegExp Record { [[IgnoreCase]]: ignoreCase, [[Multiline]]: multiline, [[DotAll]]: dotAll, [[Unicode]]: unicode, [[UnicodeSets]]: unicodeSets, [[CapturingGroupsCount]]:
capturingGroupsCount }.
22.2.2.8 Runtime Semantics: CompileCharacterClass
The syntax-directed
operation CompileCharacterClass takes argument rer (a
RegExp
Record) and returns a Record with fields
[[CharSet]] (a CharSet) and [[Invert]] (a Boolean). It is defined piecewise over the following
productions:
ClassContents can
expand into a single ClassAtom and/or ranges of two ClassAtom separated by
dashes. In the latter case the ClassContents includes all
characters between the first ClassAtom and the second ClassAtom, inclusive; an
error occurs if either ClassAtom does not represent a single
character (for example, if one is \w) or if the first ClassAtom's character value is strictly
greater than the second ClassAtom's character value.
Note 3
Even if the pattern ignores case, the case of the two ends of a range is significant
in determining which characters belong to the range. Thus, for example, the pattern
/[E-F]/i matches only the letters E, F,
e, and f, while the pattern /[E-f]/i matches
all uppercase and lowercase letters in the Unicode Basic Latin block as well as the
symbols [, \, ], ^,
_, and `.
Note 4
A - character can be treated literally or it can denote a range. It is
treated literally if it is the first or last character of ClassContents, the beginning or end
limit of a range specification, or immediately follows a range specification.
Let c be the character whose character value is cv.
Return the CharSet containing the single
character c.
Note 5
A ClassAtom can use
any of the escape sequences that are allowed in the rest of the regular expression
except for \b, \B, and backreferences. Inside a CharacterClass,
\b means the backspace character, while \B and
backreferences raise errors. Using a backreference inside a ClassAtom causes an
error.
Assert:
p is a binary Unicode property or binary property alias listed in the
“Property name and aliases” column of Table 70, or a binary
Unicode property of strings listed in the “Property name”
column of Table
71.
Let A be the CharSet containing all
CharSetElements whose character database definition includes the property
p with value “True”.
The result will often consist of two or more ranges. When UnicodeSets is
true and IgnoreCase is true, then MaybeSimpleCaseFolding(rer,
[Ā-č]) will include only the odd-numbered code points of that range.
Return the CharSet containing the single
character U+0008 (BACKSPACE).
22.2.2.9.1 CharacterRange ( A, B )
The abstract operation CharacterRange takes arguments A (a CharSet) and B (a CharSet) and returns a CharSet. It performs the following steps
when called:
Assert: A and B each
contain exactly one character.
Return the CharSet containing all characters
with a character value in the inclusive
interval from i to j.
22.2.2.9.2 HasEitherUnicodeFlag ( rer )
The abstract operation HasEitherUnicodeFlag takes argument rer (a RegExp
Record) and returns a Boolean. It performs the following steps
when called:
If rer.[[Unicode]] is
true or rer.[[UnicodeSets]] is true, then
Return true.
Return false.
22.2.2.9.3 WordCharacters ( rer )
The abstract operation WordCharacters takes argument rer (a RegExp
Record) and returns a CharSet. Returns a
CharSet containing the characters
considered "word characters" for the purposes of \b, \B,
\w, and \W It performs the following steps when called:
Let extraWordChars be the CharSet containing
all characters c such that c is not in
basicWordChars but Canonicalize(rer,
c) is in basicWordChars.
Assert: extraWordChars is empty
unless HasEitherUnicodeFlag(rer)
is true and rer.[[IgnoreCase]] is true.
Return the union of basicWordChars and extraWordChars.
22.2.2.9.4 AllCharacters ( rer )
The abstract operation AllCharacters takes argument rer (a RegExp
Record) and returns a CharSet. Returns the set
of “all characters” according to the regular expression flags. It performs the following
steps when called:
If rer.[[UnicodeSets]] is
true and rer.[[IgnoreCase]] is true, then
Return the CharSet
containing all Unicode code points c that do not have a Simple
Case Folding mapping (that is, scf(c)=c).
Return the CharSet containing all
code point values.
Else,
Return the CharSet containing all
code unit values.
22.2.2.9.5 MaybeSimpleCaseFolding ( rer,
A )
The abstract operation MaybeSimpleCaseFolding takes arguments rer (a RegExp
Record) and A (a CharSet) and returns a
CharSet. If rer.[[UnicodeSets]] is false or
rer.[[IgnoreCase]] is false, it
returns A. Otherwise, it uses the Simple Case
Folding (scf(cp)) definitions in the file CaseFolding.txt
of the Unicode Character Database (each of which maps a single code point to another
single code point) to map each CharSetElement of A
character-by-character into a canonical form and returns the resulting CharSet. It performs the following steps
when called:
If rer.[[UnicodeSets]] is
false or rer.[[IgnoreCase]] is false, return
A.
The abstract operation CharacterComplement takes arguments rer (a RegExp
Record) and S (a CharSet) and returns a
CharSet. It performs the following steps
when called:
Return the CharSet containing the
CharSetElements of A which are not also CharSetElements of
S.
22.2.2.9.7 UnicodeMatchProperty ( rer,
p )
The abstract operation UnicodeMatchProperty takes arguments rer (a RegExp
Record) and p (ECMAScript source text)
and returns a Unicode property name. It performs the following
steps when called:
If rer.[[UnicodeSets]] is
true and p is a Unicode property
name listed in the “Property name”
column of Table
71, then
Implementations must support the Unicode property names and aliases listed in Table 69, Table 70, and Table 71. To
ensure interoperability, implementations must not support any other property names or
aliases.
Note 1
For example, Script_Extensions (property name) and
scx (property alias) are valid, but script_extensions
or Scx aren't.
Note 2
The listed properties form a superset of what UTS18 RL1.2 requires.
Note 3
The spellings of entries in these tables (including casing) match the spellings
used in the file PropertyAliases.txt
in the Unicode Character Database. The precise spellings in that file are guaranteed
to be stable.
Table 69: Non-binary Unicode property aliases and their canonical
property names
The abstract operation UnicodeMatchPropertyValue takes arguments p (ECMAScript source
text) and v (ECMAScript source text)
and returns a Unicode property value. It performs the following steps when called:
Implementations must support the Unicode property values and property value aliases
listed in PropertyValueAliases.txt
for the properties listed in Table 69.
To ensure interoperability, implementations must not support any other property values
or property value aliases.
Note 1
For example, Xpeo and Old_Persian are valid
Script_Extensions values, but xpeo and
Old Persian aren't.
The syntax-directed
operation CompileClassSetString takes argument rer (a
RegExp
Record) and returns a sequence of characters. It is defined piecewise
over the following productions:
If F contains any code unit other than "d",
"g", "i", "m",
"s", "u", "v", or
"y", or if F contains any code unit more than once,
throw a SyntaxError exception.
If F contains "i", let i be
true; else let i be false.
If F contains "m", let m be
true; else let m be false.
If F contains "s", let s be
true; else let s be false.
If F contains "u", let u be
true; else let u be false.
If F contains "v", let v be
true; else let v be false.
Let rer be the RegExp Record { [[IgnoreCase]]: i, [[Multiline]]: m, [[DotAll]]: s, [[Unicode]]: u, [[UnicodeSets]]: v, [[CapturingGroupsCount]]:
capturingGroupsCount }.
Set obj.[[RegExpRecord]] to rer.
Set obj.[[RegExpMatcher]] to CompilePattern of
parseResult with argument rer.
22.2.3.4 Static Semantics: ParsePattern (
patternText, u, v )
The abstract operation ParsePattern takes arguments patternText (a sequence of
Unicode code points), u (a Boolean), and v (a Boolean) and returns a
Parse Node or a non-empty List of
SyntaxError objects.
is the initial value of the "RegExp" property of the global
object.
creates and initializes a new RegExp object when called as a constructor.
when called as a function rather than as a constructor, returns either a new RegExp object,
or the argument itself if the only argument is a RegExp object.
may be used as the value of an extends clause of a class definition. Subclass
constructors that intend to inherit the specified
RegExp behaviour must include a super call to the RegExp constructor to
create and initialize subclass instances with the necessary internal slots.
22.2.4.1 RegExp ( pattern, flags )
This function performs the following steps when called:
If pattern is supplied using a StringLiteral, the usual escape
sequence substitutions are performed before the String is processed by this
function. If pattern must contain an escape sequence to be recognized by this
function, any U+005C (REVERSE SOLIDUS) code points must be escaped within the
StringLiteral to
prevent them being removed when the contents of the StringLiteral are formed.
This function returns a copy of S in which characters that are potentially special
in a regular expression Pattern
have been replaced by equivalent escape sequences.
If escaped is the empty String and cp is matched by
either DecimalDigit or AsciiLetter,
then
NOTE: Escaping a leading digit ensures that output corresponds with
pattern text which may be used after a \0 character
escape or a DecimalEscape such
as \1 and still match S rather than be
interpreted as an extension of the preceding escape sequence.
Escaping a leading ASCII letter does the same for the context after
\c.
Despite having similar names, EscapeRegExpPattern and
RegExp.escape do not perform similar actions. The former escapes a
pattern for representation as a string, while this function escapes a string for
representation inside a pattern.
22.2.5.1.1 EncodeForRegExpEscape ( cp )
The abstract operation EncodeForRegExpEscape takes argument cp (a code point)
and returns a String. It returns a String representing a Pattern for matching cp. If
cp is white space or an ASCII punctuator, the returned value is an escape
sequence. Otherwise, the returned value is a String
representation of cp itself. It performs the following steps when called:
If cp is matched by SyntaxCharacter or
cp is U+002F (SOLIDUS), then
Else if cp is a code point listed in the “Code Point” column of
Table 67,
then
Return the string-concatenation
of 0x005C (REVERSE SOLIDUS) and the string in the “ControlEscape” column
of the row whose “Code Point” column contains cp.
Let otherPunctuators be the string-concatenation of
",-=<>#&!%:;@~'`" and the code unit 0x0022
(QUOTATION MARK).
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
22.2.5.3 get RegExp [ %Symbol.species% ]
RegExp[%Symbol.species%] is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
Return the this value.
The value of the "name" property of this function is "get
[Symbol.species]".
Note
RegExp prototype methods normally use their this value's constructor to create a derived object.
However, a subclass constructor may over-ride that default
behaviour by redefining its %Symbol.species% property.
The RegExp prototype object does not have a "valueOf" property of its
own; however, it inherits the "valueOf" property from the Object prototype
object.
22.2.6.1 RegExp.prototype.constructor
The initial value of RegExp.prototype.constructor is %RegExp%.
22.2.6.2 RegExp.prototype.exec ( string )
This method searches string for an occurrence of the regular expression pattern
and returns an Array containing the results of the match, or null if
string did not match.
RegExp.prototype.dotAll is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
Let R be the this value.
Let cu be the code unit 0x0073 (LATIN SMALL LETTER S).
RegExp.prototype.flags is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
RegExp.prototype.global is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
Let R be the this value.
Let cu be the code unit 0x0067 (LATIN SMALL LETTER G).
RegExp.prototype.hasIndices is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
Let R be the this value.
Let cu be the code unit 0x0064 (LATIN SMALL LETTER D).
RegExp.prototype.ignoreCase is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
Let R be the this value.
Let cu be the code unit 0x0069 (LATIN SMALL LETTER I).
The value of the "name" property of this method is
"[Symbol.match]".
Note
The %Symbol.match% property is
used by the IsRegExp abstract operation to identify
objects that have the basic behaviour of regular expressions. The absence of a
%Symbol.match% property or the
existence of such a property whose value does not Boolean coerce to
true indicates that the object is not intended to be used as a
regular expression object.
The value of the "name" property of this method is
"[Symbol.matchAll]".
22.2.6.10 get RegExp.prototype.multiline
RegExp.prototype.multiline is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
Let R be the this value.
Let cu be the code unit 0x006D (LATIN SMALL LETTER M).
NOTE: When n = 1, the preceding step puts the first
element into captures (at index 0). More generally, the
nth capture (the characters captured by the
nth set of capturing parentheses) is at
captures[n - 1].
Let replacementString be ? GetSubstitution(matched,
S, position, captures,
namedCaptures, replaceValue).
If position ≥ nextSourcePosition, then
NOTE: position should not normally move backwards. If it
does, it is an indication of an ill-behaving RegExp subclass or use
of an access triggered side-effect to change the global flag or
other characteristics of rx. In such cases, the
corresponding substitution is ignored.
Set accumulatedResult to the string-concatenation
of accumulatedResult, the substring of
S from nextSourcePosition to
position, and replacementString.
Set nextSourcePosition to position +
matchLength.
If nextSourcePosition ≥ lengthS, return
accumulatedResult.
The value of the "name" property of this method is
"[Symbol.search]".
Note
The "lastIndex" and "global" properties of this
RegExp object are ignored when performing the search. The
"lastIndex" property is left unchanged.
22.2.6.13 get RegExp.prototype.source
RegExp.prototype.source is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
The abstract operation EscapeRegExpPattern takes arguments P (a String) and
F (a String) and returns a String. It performs the following steps when
called:
If F contains "v", then
Let patternSymbol be Pattern[+UnicodeMode,
+UnicodeSetsMode].
Else if F contains "u", then
Let patternSymbol be Pattern[+UnicodeMode,
~UnicodeSetsMode].
Else,
Let patternSymbol be Pattern[~UnicodeMode,
~UnicodeSetsMode].
Let S be a String in the form of a patternSymbol
equivalent to P interpreted as UTF-16 encoded Unicode code points
(6.1.4),
in which certain code points are escaped as described below. S may or
may not differ from P; however, the Abstract Closure that would
result from evaluating S as a patternSymbol must behave
identically to the Abstract Closure given by
the constructed object's [[RegExpMatcher]] internal
slot. Multiple calls to this abstract operation using the same values for
P and F must produce identical results.
The code points / or any LineTerminator occurring in the
pattern shall be escaped in S as necessary to ensure that the
string-concatenation of
"/", S, "/", and F
can be parsed (in an appropriate lexical context) as a RegularExpressionLiteral
that behaves identically to the constructed regular expression. For example, if
P is "/", then S could be
"\/" or "\u002F", among other
possibilities, but not "/", because /// followed
by F would be parsed as a SingleLineComment rather
than a RegularExpressionLiteral.
If P is the empty String, this specification can be met by letting
S be "(?:)".
Return S.
Note
Despite having similar names, RegExp.escape and EscapeRegExpPattern
do not perform similar actions. The former escapes a string for representation
inside a pattern, while this function escapes a pattern for representation as a
string.
This method returns an Array into which substrings of the result of converting
string to a String have been stored. The substrings are determined by
searching from left to right for matches of the this value
regular expression; these occurrences are not part of any String in the returned
array, but serve to divide up the String value.
The this value may be an empty regular expression or a regular
expression that can match an empty String. In this case, the regular expression does
not match the empty substring at the beginning or end of
the input String, nor does it match the empty substring
at the end of the previous separator match. (For example, if the regular expression
matches the empty String, the String is split up into individual code unit elements;
the length of the result array equals the length of the String, and each
substring contains one code unit.) Only the first match
at a given index of the String is considered, even if backtracking could yield a
non-empty substring match at that index. (For example,
/a*?/[Symbol.split]("ab") evaluates to the array
["a", "b"], while /a*/[Symbol.split]("ab") evaluates to
the array ["","b"].)
If string is (or converts to) the empty String, the result depends on
whether the regular expression can match the empty String. If it can, the result
array contains no elements. Otherwise, the result array contains one element, which
is the empty String.
If the regular expression contains capturing parentheses, then each time
separator is matched the results (including any
undefined results) of the capturing parentheses are spliced into
the output array. For example,
The value of the "name" property of this method is
"[Symbol.split]".
Note 2
This method ignores the value of the "global" and
"sticky" properties of this RegExp object.
22.2.6.15 get RegExp.prototype.sticky
RegExp.prototype.sticky is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
Let R be the this value.
Let cu be the code unit 0x0079 (LATIN SMALL LETTER Y).
The returned String has the form of a RegularExpressionLiteral
that evaluates to another RegExp object with the same behaviour as this object.
22.2.6.18 get RegExp.prototype.unicode
RegExp.prototype.unicode is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
Let R be the this value.
Let cu be the code unit 0x0075 (LATIN SMALL LETTER U).
RegExp.prototype.unicodeSets is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
Let R be the this value.
Let cu be the code unit 0x0076 (LATIN SMALL LETTER V).
The abstract operation RegExpExec takes arguments R (an Object) and S
(a String) and returns either a normal completion
containing either an Object or null, or a
throw completion. It
performs the following steps when called:
If a callable "exec" property is not found this algorithm falls
back to attempting to use the built-in RegExp matching algorithm. This provides
compatible behaviour for code written for prior editions where most built-in
algorithms that use regular expressions did not perform a dynamic property lookup of
"exec".
22.2.7.2 RegExpBuiltinExec ( R, S )
The abstract operation RegExpBuiltinExec takes arguments R (an initialized RegExp
instance) and S (a String) and returns either a normal completion
containing either an Array exotic object or
null, or a throw
completion. It performs the following steps when called:
Let length be the length of S.
Let lastIndex be ℝ(? ToLength(? Get(R,
"lastIndex"))).
Let flags be R.[[OriginalFlags]].
If flags contains "g", let global be
true; else let global be false.
If flags contains "y", let sticky be
true; else let sticky be false.
If flags contains "d", let hasIndices be
true; else let hasIndices be false.
If global is false and sticky is
false, set lastIndex to 0.
Let matcher be R.[[RegExpMatcher]].
If flags contains "u" or flags contains
"v", let fullUnicode be true; else
let fullUnicode be false.
Let matchSucceeded be false.
If fullUnicode is true, let input be
StringToCodePoints(S);
otherwise let input be a List whose
elements are the code units that are the elements of S.
NOTE: Each element of input is considered to be a character.
If capturedValue is not
undefined, append s to
matchedGroupNames.
NOTE: If there are multiple groups named s,
groups may already have an s property
at this point. However, because groups is an
ordinary
object whose properties are all
writable data
properties, the call to CreateDataPropertyOrThrow
is nevertheless guaranteed to succeed.
The abstract operation AdvanceStringIndex takes arguments S (a String),
index (a non-negative integer), and unicode (a Boolean) and
returns an integer. It performs the following steps when called:
The abstract operation GetStringIndex takes arguments S (a String) and
codePointIndex (a non-negative integer) and returns a non-negative integer. It interprets
S as a sequence of UTF-16 encoded code points, as described in 6.1.4, and returns
the code unit index corresponding to code point index codePointIndex when such an
index exists. Otherwise, it returns the length of S. It performs the following
steps when called:
If S is the empty String, return 0.
Let len be the length of S.
Let codeUnitCount be 0.
Let codePointCount be 0.
Repeat, while codeUnitCount < len,
If codePointCount = codePointIndex, return
codeUnitCount.
The number of code units from the start of a string at which the match
ends (exclusive).
22.2.7.6 GetMatchString ( S, match )
The abstract operation GetMatchString takes arguments S (a String) and
match (a Match Record) and returns a String. It
performs the following steps when called:
Assert:
match.[[StartIndex]] ≤ match.[[EndIndex]] ≤ the length of S.
Return the substring of S from
match.[[StartIndex]] to match.[[EndIndex]].
22.2.7.7 GetMatchIndexPair ( S, match )
The abstract operation GetMatchIndexPair takes arguments S (a String) and
match (a Match Record) and returns an Array. It
performs the following steps when called:
Assert:
match.[[StartIndex]] ≤ match.[[EndIndex]] ≤ the length of S.
The abstract operation MakeMatchIndicesIndexPairArray takes arguments S (a
String), indices (a List of
either Match Records or
undefined), groupNames (a List of either Strings
or undefined), and hasGroups (a Boolean) and returns an Array.
It performs the following steps when called:
NOTE: If there are multiple groups named s,
groups may already have an s property
at this point. However, because groups is an
ordinary
object whose properties are all
writable data
properties, the call to CreateDataPropertyOrThrow
is nevertheless guaranteed to succeed.
RegExp instances are ordinary objects that inherit properties from the
RegExp prototype
object. RegExp instances have internal slots [[OriginalSource]], [[OriginalFlags]], [[RegExpRecord]], and [[RegExpMatcher]]. The
value of the [[RegExpMatcher]] internal slot is an Abstract
Closure representation of the Pattern of the RegExp object.
Note
Prior to ECMAScript 2015, RegExp instances were specified as having the own data
properties"source",
"global", "ignoreCase", and
"multiline". Those properties are now specified as accessor
properties of RegExp.prototype.
RegExp instances also have the following property:
22.2.8.1 lastIndex
The value of the "lastIndex" property specifies the String index at which
to start the next match. It is coerced to an integral Number when used (see
22.2.7.2). This property shall have the
attributes { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }.
22.2.9 RegExp String Iterator Objects
A RegExp String Iterator is an object that represents a specific iteration
over some specific String instance object, matching against some specific RegExp instance
object. There is not a named constructor for RegExp String Iterator objects.
Instead, RegExp String Iterator objects are created by calling certain methods of RegExp
instance objects.
The abstract operation CreateRegExpStringIterator takes arguments R (an Object),
S (a String), global (a Boolean), and fullUnicode (a
Boolean) and returns an Object. It performs the following steps when called:
is the initial value of the "Array" property of the global
object.
creates and initializes a new Array when called as a constructor.
also creates and initializes a new Array when called as a function rather than as a
constructor. Thus the function call
Array(…) is equivalent to the object creation expression
new Array(…) with the same arguments.
is a function whose behaviour differs based upon the number and types of its arguments.
may be used as the value of an extends clause of a class definition. Subclass
constructors that intend to inherit the exotic
Array behaviour must include a super call to the Array constructor to
initialize subclass instances that are Array exotic objects.
However, most of the Array.prototype methods are generic methods that are not
dependent upon their this value being an Array exotic
object.
23.1.1.1 Array ( ...values )
This function performs the following steps when called:
If NewTarget is undefined, let newTarget be the
active function object; else
let newTarget be NewTarget.
This method is an intentionally generic factory method; it does not require that its
this value be the Array constructor. Therefore it
can be transferred to or inherited by any other constructors that may be
called with a single numeric argument.
23.1.2.2 Array.isArray ( arg )
This function performs the following steps when called:
This method is an intentionally generic factory method; it does not require that its
this value be the Array constructor. Therefore it
can be transferred to or inherited by other constructors that may be
called with a single numeric argument.
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
23.1.2.5 get Array [ %Symbol.species% ]
Array[%Symbol.species%] is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
Return the this value.
The value of the "name" property of this function is "get
[Symbol.species]".
Note
Array prototype methods normally use their this value's constructor to create a derived object.
However, a subclass constructor may over-ride that default
behaviour by redefining its %Symbol.species% property.
23.1.3 Properties of the Array Prototype Object
The Array prototype object:
is %Array.prototype%.
is an Array exotic object and has the internal
methods specified for such objects.
has a "length" property whose initial value is
+0𝔽 and whose attributes are { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }.
The Array prototype object is specified to be an Array exotic object to
ensure compatibility with ECMAScript code that was created prior to the ECMAScript 2015
specification.
The explicit setting of the "length" property in step 6 is intended to
ensure the length is correct when the final non-empty element of items
has trailing holes or when A is not a built-in Array.
Note 2
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
The initial value of Array.prototype.constructor is %Array%.
23.1.3.4 Array.prototype.copyWithin ( target,
start [ , end ] )
Note 1
The end argument is optional. If it is not provided, the length of the
this value is used.
Note 2
If target is negative, it is treated as length + target where
length is the length of the array. If start is negative, it is
treated as length + start.
If end is negative, it is treated as length + end.
This method performs the following steps when called:
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
23.1.3.5 Array.prototype.entries ( )
This method performs the following steps when called:
callback should be a function that accepts three arguments and returns a
value that is coercible to a Boolean value. every calls
callback once for each element present in the array, in ascending order,
until it finds one where callback returns false. If
such an element is found, every immediately returns
false. Otherwise, every returns
true. callback is called only for elements of the
array which actually exist; it is not called for missing elements of the array.
If a thisArg parameter is provided, it will be used as the
this value for each invocation of callback. If it is
not provided, undefined is used instead.
callback is called with three arguments: the value of the element, the
index of the element, and the object being traversed.
every does not directly mutate the object on which it is called but the
object may be mutated by the calls to callback.
The range of elements processed by every is set before the first call to
callback. Elements which are appended to the array after the call to
every begins will not be visited by callback. If existing
elements of the array are changed, their value as passed to callback will
be the value at the time every visits them; elements that are deleted
after the call to every begins and before being visited are not
visited. every acts like the "for all" quantifier in mathematics. In
particular, for an empty array, it returns true.
This method performs the following steps when called:
Let testResult be ToBoolean(? Call(callback,
thisArg, « kValue, 𝔽(k),
O »)).
If testResult is false, return
false.
Set k to k + 1.
Return true.
Note 2
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
23.1.3.7 Array.prototype.fill ( value [ ,
start [ , end ] ] )
Note 1
The start argument is optional. If it is not provided,
+0𝔽 is used.
The end argument is optional. If it is not provided, the length of the
this value is used.
Note 2
If start is negative, it is treated as length + start where
length is the length of the array. If end is negative, it is
treated as length + end.
This method performs the following steps when called:
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
callback should be a function that accepts three arguments and returns a
value that is coercible to a Boolean value. filter calls
callback once for each element in the array, in ascending order, and
constructs a new array of all the values for which callback returns
true. callback is called only for elements of the
array which actually exist; it is not called for missing elements of the array.
If a thisArg parameter is provided, it will be used as the
this value for each invocation of callback. If it is
not provided, undefined is used instead.
callback is called with three arguments: the value of the element, the
index of the element, and the object being traversed.
filter does not directly mutate the object on which it is called but the
object may be mutated by the calls to callback.
The range of elements processed by filter is set before the first call
to callback. Elements which are appended to the array after the call to
filter begins will not be visited by callback. If existing
elements of the array are changed their value as passed to callback will
be the value at the time filter visits them; elements that are deleted
after the call to filter begins and before being visited are not
visited.
This method performs the following steps when called:
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
This method calls predicate once for each element of the array, in
ascending index order, until it finds one where predicate returns a value
that coerces to true. If such an element is found,
find immediately returns that element value. Otherwise,
find returns undefined.
Let findRec be ? FindViaPredicate(O,
len, ascending, predicate,
thisArg).
Return findRec.[[Value]].
Note 2
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
This method calls predicate once for each element of the array, in
ascending index order, until it finds one where predicate returns a value
that coerces to true. If such an element is found,
findIndex immediately returns the index of that element value.
Otherwise, findIndex returns -1.
Let findRec be ? FindViaPredicate(O,
len, ascending, predicate,
thisArg).
Return findRec.[[Index]].
Note 2
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
This method calls predicate once for each element of the array, in
descending index order, until it finds one where predicate returns a
value that coerces to true. If such an element is found,
findLast immediately returns that element value. Otherwise,
findLast returns undefined.
Let findRec be ? FindViaPredicate(O,
len, descending, predicate,
thisArg).
Return findRec.[[Value]].
Note 2
This method is intentionally generic; it does not require that its
this value be an Array object. Therefore it can be transferred to
other kinds of objects for use as a method.
This method calls predicate once for each element of the array, in
descending index order, until it finds one where predicate returns a
value that coerces to true. If such an element is found,
findLastIndex immediately returns the index of that element value.
Otherwise, findLastIndex returns -1.
Let findRec be ? FindViaPredicate(O,
len, descending, predicate,
thisArg).
Return findRec.[[Index]].
Note 2
This method is intentionally generic; it does not require that its
this value be an Array object. Therefore it can be transferred to
other kinds of objects for use as a method.
23.1.3.12.1 FindViaPredicate ( O, len,
direction, predicate, thisArg )
O should be an array-like object or a TypedArray.
This operation calls predicate once for each element of O, in
either ascending index order or descending index order (as indicated by
direction), until it finds one where predicate returns a value
that coerces to true. At that point, this operation returns a
Record that gives
the index and value of the element found. If no such element is found, this operation
returns a Record that
specifies -1𝔽 for the index and
undefined for the value.
predicate should be a function. When called for an element of the array, it is
passed three arguments: the value of the element, the index of the element, and the
object being traversed. Its return value will be coerced to a Boolean value.
thisArg will be used as the this value for each invocation
of predicate.
This operation does not directly mutate the object on which it is called, but the object
may be mutated by the calls to predicate.
The range of elements processed is set before the first call to predicate,
just before the traversal begins. Elements that are appended to the array after this
will not be visited by predicate. If existing elements of the array are
changed, their value as passed to predicate will be the value at the time
that this operation visits them. Elements that are deleted after traversal begins and
before being visited are still visited and are either looked up from the prototype or
are undefined.
It performs the following steps when called:
If IsCallable(predicate)
is false, throw a TypeError exception.
If direction is ascending, then
Let indices be a List
of the integers in the interval from 0 (inclusive) to
len (exclusive), in ascending order.
Else,
Let indices be a List
of the integers in the interval from 0 (inclusive) to
len (exclusive), in descending order.
callback should be a function that accepts three arguments.
forEach calls callback once for each element present in the
array, in ascending order. callback is called only for elements of the
array which actually exist; it is not called for missing elements of the array.
If a thisArg parameter is provided, it will be used as the
this value for each invocation of callback. If it is
not provided, undefined is used instead.
callback is called with three arguments: the value of the element, the
index of the element, and the object being traversed.
forEach does not directly mutate the object on which it is called but
the object may be mutated by the calls to callback.
The range of elements processed by forEach is set before the first call
to callback. Elements which are appended to the array after the call to
forEach begins will not be visited by callback. If existing
elements of the array are changed, their value as passed to callback will
be the value at the time forEach visits them; elements that are deleted
after the call to forEach begins and before being visited are not
visited.
This method performs the following steps when called:
Perform ? Call(callback,
thisArg, « kValue, 𝔽(k),
O »).
Set k to k + 1.
Return undefined.
Note 2
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
This method compares searchElement to the elements of the array, in
ascending order, using the SameValueZero algorithm, and if
found at any position, returns true; otherwise, it returns
false.
The optional second argument fromIndex defaults to
+0𝔽 (i.e. the whole array is searched). If it is
greater than or equal to the length of the array, false is
returned, i.e. the array will not be searched. If it is less than
-0𝔽, it is used as the offset from the end of the
array to compute fromIndex. If the computed index is less than or equal
to +0𝔽, the whole array will be searched.
This method performs the following steps when called:
If SameValueZero(searchElement,
elementK) is true, return
true.
Set k to k + 1.
Return false.
Note 2
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
Note 3
This method intentionally differs from the similar indexOf method in two
ways. First, it uses the SameValueZero algorithm, instead of
IsStrictlyEqual, allowing it to
detect NaN array elements. Second, it does not skip missing array
elements, instead treating them as undefined.
This method compares searchElement to the elements of the array, in ascending
order, using the IsStrictlyEqual algorithm, and if found
at one or more indices, returns the smallest such index; otherwise, it returns
-1𝔽.
Note 1
The optional second argument fromIndex defaults to
+0𝔽 (i.e. the whole array is searched). If it is
greater than or equal to the length of the array, -1𝔽
is returned, i.e. the array will not be searched. If it is less than
-0𝔽, it is used as the offset from the end of the
array to compute fromIndex. If the computed index is less than or equal
to +0𝔽, the whole array will be searched.
This method performs the following steps when called:
If IsStrictlyEqual(searchElement,
elementK) is true, return 𝔽(k).
Set k to k + 1.
Return -1𝔽.
Note 2
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
23.1.3.18 Array.prototype.join ( separator )
This method converts the elements of the array to Strings, and then concatenates these
Strings, separated by occurrences of the separator. If no separator is provided,
a single comma is used as the separator.
This method is intentionally generic; it does not require that its
this value be an Array. Therefore, it can be transferred to other
kinds of objects for use as a method.
23.1.3.19 Array.prototype.keys ( )
This method performs the following steps when called:
This method compares searchElement to the elements of the array in
descending order using the IsStrictlyEqual algorithm, and if
found at one or more indices, returns the largest such index; otherwise, it returns
-1𝔽.
The optional second argument fromIndex defaults to the array's length
minus one (i.e. the whole array is searched). If it is greater than or equal to the
length of the array, the whole array will be searched. If it is less than
-0𝔽, it is used as the offset from the end of the
array to compute fromIndex. If the computed index is less than or equal
to +0𝔽, -1𝔽 is
returned.
This method performs the following steps when called:
If IsStrictlyEqual(searchElement,
elementK) is true, return 𝔽(k).
Set k to k - 1.
Return -1𝔽.
Note 2
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
callback should be a function that accepts three arguments.
map calls callback once for each element in the array, in
ascending order, and constructs a new Array from the results. callback is
called only for elements of the array which actually exist; it is not called for
missing elements of the array.
If a thisArg parameter is provided, it will be used as the
this value for each invocation of callback. If it is
not provided, undefined is used instead.
callback is called with three arguments: the value of the element, the
index of the element, and the object being traversed.
map does not directly mutate the object on which it is called but the
object may be mutated by the calls to callback.
The range of elements processed by map is set before the first call to
callback. Elements which are appended to the array after the call to
map begins will not be visited by callback. If existing
elements of the array are changed, their value as passed to callback will
be the value at the time map visits them; elements that are deleted
after the call to map begins and before being visited are not visited.
This method performs the following steps when called:
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
23.1.3.22 Array.prototype.pop ( )
Note 1
This method removes the last element of the array and returns it.
This method performs the following steps when called:
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
23.1.3.23 Array.prototype.push ( ...items )
Note 1
This method appends the arguments to the end of the array, in the order in which they
appear. It returns the new length of the array.
This method performs the following steps when called:
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
callback should be a function that takes four arguments.
reduce calls the callback, as a function, once for each element after
the first element present in the array, in ascending order.
callback is called with four arguments: the previousValue
(value from the previous call to callback), the currentValue
(value of the current element), the currentIndex, and the object being
traversed. The first time that callback is called, the previousValue and
currentValue can be one of two values. If an initialValue was
supplied in the call to reduce, then previousValue will be
initialValue and currentValue will be the first value in the
array. If no initialValue was supplied, then previousValue
will be the first value in the array and currentValue will be the second.
It is a TypeError if the array contains no elements and
initialValue is not provided.
reduce does not directly mutate the object on which it is called but the
object may be mutated by the calls to callback.
The range of elements processed by reduce is set before the first call
to callback. Elements that are appended to the array after the call to
reduce begins will not be visited by callback. If existing
elements of the array are changed, their value as passed to callback will
be the value at the time reduce visits them; elements that are deleted
after the call to reduce begins and before being visited are not
visited.
This method performs the following steps when called:
Set accumulator to ? Call(callback,
undefined, « accumulator,
kValue, 𝔽(k),
O »).
Set k to k + 1.
Return accumulator.
Note 2
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
callback should be a function that takes four arguments.
reduceRight calls the callback, as a function, once for each element
after the first element present in the array, in descending order.
callback is called with four arguments: the previousValue
(value from the previous call to callback), the currentValue
(value of the current element), the currentIndex, and the object being
traversed. The first time the function is called, the previousValue and
currentValue can be one of two values. If an initialValue was
supplied in the call to reduceRight, then previousValue will
be initialValue and currentValue will be the last value in the
array. If no initialValue was supplied, then previousValue
will be the last value in the array and currentValue will be the
second-to-last value. It is a TypeError if the array contains no
elements and initialValue is not provided.
reduceRight does not directly mutate the object on which it is called
but the object may be mutated by the calls to callback.
The range of elements processed by reduceRight is set before the first
call to callback. Elements that are appended to the array after the call
to reduceRight begins will not be visited by callback. If
existing elements of the array are changed by callback, their value as
passed to callback will be the value at the time reduceRight
visits them; elements that are deleted after the call to reduceRight
begins and before being visited are not visited.
This method performs the following steps when called:
Set accumulator to ? Call(callback,
undefined, « accumulator,
kValue, 𝔽(k),
O »).
Set k to k - 1.
Return accumulator.
Note 2
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
23.1.3.26 Array.prototype.reverse ( )
Note 1
This method rearranges the elements of the array so as to reverse their order. It
returns the reversed array.
This method performs the following steps when called:
Assert: lowerExists
and upperExists are both false.
NOTE: No action is required.
Set lower to lower + 1.
Return O.
Note 2
This method is intentionally generic; it does not require that its
this value be an Array. Therefore, it can be transferred to other
kinds of objects for use as a method.
23.1.3.27 Array.prototype.shift ( )
This method removes the first element of the array and returns it.
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
23.1.3.28 Array.prototype.slice ( start,
end )
This method returns an array containing the elements of the array from element
start up to, but not including, element end (or through the end of the
array if end is undefined). If start is negative,
it is treated as length + start
where length is the length of the array. If end is negative, it is
treated as length + end where
length is the length of the array.
The explicit setting of the "length" property in step 15 is intended to
ensure the length is correct even when A is not a built-in Array.
Note 2
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
callback should be a function that accepts three arguments and returns a
value that is coercible to a Boolean value. some calls
callback once for each element present in the array, in ascending order,
until it finds one where callback returns true. If
such an element is found, some immediately returns
true. Otherwise, some returns
false. callback is called only for elements of the
array which actually exist; it is not called for missing elements of the array.
If a thisArg parameter is provided, it will be used as the
this value for each invocation of callback. If it is
not provided, undefined is used instead.
callback is called with three arguments: the value of the element, the
index of the element, and the object being traversed.
some does not directly mutate the object on which it is called but the
object may be mutated by the calls to callback.
The range of elements processed by some is set before the first call to
callback. Elements that are appended to the array after the call to
some begins will not be visited by callback. If existing
elements of the array are changed, their value as passed to callback will
be the value at the time that some visits them; elements that are
deleted after the call to some begins and before being visited are not
visited. some acts like the "exists" quantifier in mathematics. In
particular, for an empty array, it returns false.
This method performs the following steps when called:
Let testResult be ToBoolean(? Call(callback,
thisArg, « kValue, 𝔽(k),
O »)).
If testResult is true, return
true.
Set k to k + 1.
Return false.
Note 2
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
23.1.3.30 Array.prototype.sort ( comparator )
This method sorts the elements of this array. If comparator is not
undefined, it should be a function that accepts two arguments
x and y and returns a negative Number if x <
y, a positive Number if x > y, or a zero otherwise.
It performs the following steps when called:
If comparator is not
undefined and IsCallable(comparator) is
false, throw a TypeError exception.
NOTE: The call to SortIndexedProperties in
step 5 uses
skip-holes. The remaining indices are deleted to preserve the
number of holes that were detected and excluded from the sort.
Because non-existent property values always compare greater than
undefined property values, and undefined
always compares greater than any other value (see CompareArrayElements),
undefined property values always sort to the end of the result,
followed by non-existent property values.
This method is intentionally generic; it does not require that its
this value be an Array. Therefore, it can be transferred to other
kinds of objects for use as a method.
There must be some mathematical permutation π of the non-negative integers less
than itemCount, such that for every non-negative integerj less than itemCount, the element old[j] is exactly the same as new[π(j)].
Then for all non-negative integersj and k, each
less than itemCount, if ℝ(SortCompare(old[j],
old[k])) < 0, then π(j) < π(k).
And for all non-negative integersj and k such
that j < k < itemCount, if ℝ(SortCompare(old[j],
old[k])) = 0, then π(j)
< π(k); i.e., the sort is stable.
Here the notation old[j] is used to refer to
items[j] before step 4 is
executed, and the notation new[j] to refer
to items[j] after step 4
has been executed.
An abstract closure or function comparator is a consistent comparator for a set of
values S if all of the requirements below are met for all values
a, b, and c (possibly the same value) in the set
S: The notation a <Cb means ℝ(comparator(a,
b)) < 0; a =Cb means ℝ(comparator(a,
b)) = 0; and a
>Cb means ℝ(comparator(a,
b)) > 0.
Calling comparator(a, b) always returns the same
value v when given a specific pair of values a and
b as its two arguments. Furthermore, vis a
Number, and v is not NaN. Note
that this implies that exactly one of a <Cb,
a =Cb, and a >Cb will be true for a given pair of a and b.
Calling comparator(a, b) does not modify
obj or any object on obj's prototype chain.
a =Ca (reflexivity)
If a =Cb, then b =Ca (symmetry)
If a =Cb and b =Cc, then a =Cc (transitivity of
=C)
If a <Cb and b <Cc, then a <Cc (transitivity of
<C)
If a >Cb and b >Cc, then a >Cc (transitivity of
>C)
Note
The above conditions are necessary and sufficient to ensure that
comparator divides the set S into equivalence classes and
that these equivalence classes are totally ordered.
23.1.3.30.2 CompareArrayElements ( x,
y, comparator )
This method deletes the deleteCount elements of the array starting at
integer
indexstart and replaces them with the elements of
items. It returns an Array containing the deleted elements (if any).
This method performs the following steps when called:
The explicit setting of the "length" property in steps 15 and 20 is intended
to ensure the lengths are correct even when the objects are not built-in Arrays.
Note 3
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
An ECMAScript implementation that includes the ECMA-402 Internationalization API must
implement this method as specified in the ECMA-402 specification. If an ECMAScript
implementation does not include the ECMA-402 API the following specification of this method
is used.
Note 1
The first edition of ECMA-402 did not include a replacement specification for this
method.
The meanings of the optional parameters to this method are defined in the ECMA-402
specification; implementations that do not include ECMA-402 support must not use those
parameter positions for anything else.
This method performs the following steps when called:
This method converts the elements of the array to Strings using their
toLocaleString methods, and then concatenates these Strings, separated
by occurrences of an implementation-defined
locale-sensitive separator String. This method is analogous to toString
except that it is intended to yield a locale-sensitive result corresponding with
conventions of the host environment's current locale.
Note 3
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
23.1.3.33 Array.prototype.toReversed ( )
This method performs the following steps when called:
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
23.1.3.37 Array.prototype.unshift ( ...items )
This method prepends the arguments to the start of the array, such that their order within
the array is the same as the order in which they appear in the argument list.
This method is intentionally generic; it does not require that its
this value be an Array. Therefore it can be transferred to other
kinds of objects for use as a method.
23.1.3.38 Array.prototype.values ( )
This method performs the following steps when called:
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: true }.
Note
The own property names of this object are property names that were not included as
standard properties of Array.prototype prior to the ECMAScript 2015
specification. These names are ignored for with statement binding
purposes in order to preserve the behaviour of existing code that might use one of
these names as a binding in an outer scope that is shadowed by a with
statement whose binding object is an Array.
The reason that "with" is not included in the
unscopableList is because it is already a reserved word.
Array instances have a "length" property, and a set of enumerable properties
with array
index names.
23.1.4.1 length
The "length" property of an Array instance is a data
property whose value is always numerically greater than the name of
every configurable own property whose name is an array index.
The "length" property initially has the attributes { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false }.
Note
Reducing the value of the "length" property has the side-effect of
deleting own array elements whose array index is between the old and new
length values. However, non-configurable properties can not be deleted. Attempting
to set the "length" property of an Array to a value that is
numerically less than or equal to the largest numeric own property
name of an existing non-configurable array-indexed property of the array will
result in the length being set to a numeric value that is one greater than that
non-configurable numeric own property name. See 10.4.2.1.
23.1.5 Array Iterator Objects
An Array Iterator is an object that represents a specific iteration over
some specific Array instance object. There is not a named constructor for Array Iterator
objects. Instead, Array Iterator objects are created by calling certain methods of Array
instance objects.
23.1.5.1 CreateArrayIterator ( array, kind
)
The abstract operation CreateArrayIterator takes arguments array (an Object) and
kind (key+value, key, or
value) and returns an Object. It is used to create iterator objects for Array methods
that return such iterators. It performs the following
steps when called:
A value that identifies what is returned for each element of the
iteration.
23.2 TypedArray Objects
A TypedArray presents an array-like view of an underlying binary data buffer (25.1). A TypedArray element type is the
underlying binary scalar data type that all elements of a TypedArray instance have. There
is a distinct TypedArrayconstructor, listed in Table 75, for each of the supported
element types. Each constructor in Table 75 has a corresponding
distinct prototype object.
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
23.2.2.4 get %TypedArray% [ %Symbol.species% ]
%TypedArray%[%Symbol.species%]
is an accessor
property whose set accessor function is undefined.
Its get accessor function performs the following steps when called:
Return the this value.
The value of the "name" property of this function is "get
[Symbol.species]".
%TypedArray%.prototype.buffer
is an accessor
property whose set accessor function is undefined.
Its get accessor function performs the following steps when called:
Assert:
O has a [[ViewedArrayBuffer]] internal slot.
Let buffer be O.[[ViewedArrayBuffer]].
Return buffer.
23.2.3.3 get %TypedArray%.prototype.byteLength
%TypedArray%.prototype.byteLength
is an accessor
property whose set accessor function is undefined.
Its get accessor function performs the following steps when called:
%TypedArray%.prototype.byteOffset
is an accessor
property whose set accessor function is undefined.
Its get accessor function performs the following steps when called:
If IsStrictlyEqual(searchElement,
elementK) is true, return 𝔽(k).
Set k to k - 1.
Return -1𝔽.
This method is not generic. The this value must be an object with a [[TypedArrayName]] internal slot.
23.2.3.21 get %TypedArray%.prototype.length
%TypedArray%.prototype.length
is an accessor
property whose set accessor function is undefined.
Its get accessor function performs the following steps when called:
This method sets multiple values in this TypedArray, reading the values from
source. The details differ based upon the type of source. The optional
offset value indicates the first element index in this TypedArray
where values are written. If omitted, it is assumed to be 0.
The abstract operation SetTypedArrayFromArrayLike takes arguments target (a
TypedArray), targetOffset (a
non-negative integer or +∞), and source (an
ECMAScript language value,
but not a TypedArray) and returns either a normal completion
containingunused or a throw
completion. It sets multiple values in target,
starting at index targetOffset, reading the values from source. It
performs the following steps when called:
The abstract operation SetTypedArrayFromTypedArray takes arguments target (a
TypedArray), targetOffset (a
non-negative integer or +∞), and source (a
TypedArray) and returns either a normal completion
containingunused or a throw
completion. It sets multiple values in target,
starting at index targetOffset, reading the values from source. It
performs the following steps when called:
If targetOffset = +∞, throw a RangeError
exception.
If srcLength + targetOffset > targetLength,
throw a RangeError exception.
If target.[[ContentType]] is not
source.[[ContentType]], throw a
TypeError exception.
If IsSharedArrayBuffer(srcBuffer)
is true, IsSharedArrayBuffer(targetBuffer)
is true, and srcBuffer.[[ArrayBufferData]] is targetBuffer.[[ArrayBufferData]], let
sameSharedArrayBuffer be true; otherwise let
sameSharedArrayBuffer be false.
If SameValue(srcBuffer,
targetBuffer) is true or
sameSharedArrayBuffer is true, then
This is a distinct method that, except as described below, implements the same requirements
as those of Array.prototype.sort as defined in 23.1.3.30. The implementation of
this method may be optimized with the knowledge that the this value is an
object that has a fixed length and whose integer-indexed properties are not sparse.
This method is not generic. The this value must be an object with a [[TypedArrayName]] internal slot.
It performs the following steps when called:
If comparator is not undefined and IsCallable(comparator) is
false, throw a TypeError exception.
Because NaN always compares greater than any other value (see
CompareTypedArrayElements),
NaN property values always sort to the end of the result when
comparator is not provided.
23.2.3.30 %TypedArray%.prototype.subarray ( start,
end )
This method returns a new TypedArray whose element type is the element type of
this TypedArray and whose ArrayBuffer is the ArrayBuffer of this
TypedArray, referencing the elements in the interval from start
(inclusive) to end (exclusive). If either start or end is
negative, it refers to an index from the end of the array, as opposed to from the beginning.
This is a distinct method that implements the same algorithm as
Array.prototype.toLocaleString as defined in 23.1.3.32 except that
TypedArrayLength is called in place of
performing a [[Get]] of "length". The
implementation of the algorithm may be optimized with the knowledge that the
this value has a fixed length when the underlying buffer is not resizable
and whose integer-indexed properties are not sparse.
However, such optimization must not introduce any observable changes in the specified
behaviour of the algorithm.
This method is not generic. ValidateTypedArray is called with the
this value and seq-cst as arguments prior to
evaluating the algorithm. If its result is an abrupt completion
that exception is thrown instead of evaluating the algorithm.
Note
If the ECMAScript implementation includes the ECMA-402 Internationalization API this
method is based upon the algorithm for Array.prototype.toLocaleString
that is in the ECMA-402 specification.
23.2.3.32 %TypedArray%.prototype.toReversed ( )
This method performs the following steps when called:
The initial value of the %Symbol.iterator% property is
%TypedArray.prototype.values%, defined in 23.2.3.35.
23.2.3.38 get %TypedArray%.prototype [ %Symbol.toStringTag% ]
%TypedArray%.prototype[%Symbol.toStringTag%]
is an accessor
property whose set accessor function is undefined.
Its get accessor function performs the following steps when called:
The abstract operation TypedArrayElementSize takes argument O (a TypedArray) and
returns a non-negative integer. It performs the following steps when called:
Return the Element Size value specified in Table 75 for
O.[[TypedArrayName]].
23.2.4.6 TypedArrayElementType ( O )
The abstract operation TypedArrayElementType takes argument O (a TypedArray) and
returns a TypedArray element type. It performs
the following steps when called:
Return the Element Type value specified in Table 75 for
O.[[TypedArrayName]].
23.2.4.7 CompareTypedArrayElements ( x, y,
comparator )
The abstract operation CompareTypedArrayElements takes arguments x (a Number or a
BigInt), y (a Number or a BigInt), and comparator (a function
object or undefined) and returns either a
normal completion
containing a Number or an abrupt completion.
It performs the following steps when called:
is an intrinsic object that has the structure described below, differing only in the name
used as the constructor name instead of
TypedArray, in Table 75.
is a function whose behaviour differs based upon the number and types of its arguments. The
actual behaviour of a call of TypedArray depends upon the number and kind of
arguments that are passed to it.
is not intended to be called as a function and will throw an exception when called in that
manner.
may be used as the value of an extends clause of a class definition. Subclass
constructors that intend to inherit the specified
TypedArray behaviour must include a super call to the
TypedArrayconstructor to create and initialize the subclass
instance with the internal state necessary to support the %TypedArray%.prototype
built-in methods.
23.2.5.1TypedArray ( ...args )
Each TypedArrayconstructor performs the following steps when
called:
If NewTarget is undefined, throw a TypeError
exception.
Let constructorName be the String value of the Constructor Name value specified in
Table 75 for this
TypedArrayconstructor.
Let proto be "%TypedArray.prototype%".
Let numberOfArgs be the number of elements in args.
The abstract operation AllocateTypedArray takes arguments constructorName (a
String which is the name of a TypedArrayconstructor in Table 75),
newTarget (a constructor), and defaultProto (a
String) and optional argument length (a non-negative integer) and
returns either a normal
completion containing a TypedArray or a throw
completion. It is used to validate and create an instance of a
TypedArrayconstructor. If the
length argument is passed, an ArrayBuffer of that length is also allocated
and associated with the new TypedArray instance. AllocateTypedArray
provides common semantics that is used by TypedArray. It performs the
following steps when called:
23.2.5.1.5 InitializeTypedArrayFromArrayLike ( O,
arrayLike )
The abstract operation InitializeTypedArrayFromArrayLike takes arguments O (a
TypedArray) and arrayLike (an
Object, but not a TypedArray or an ArrayBuffer) and returns
either a normal completion
containingunused or a throw
completion. It performs the following steps when called:
The abstract operation AllocateTypedArrayBuffer takes arguments O (a TypedArray)
and length (a non-negative integer) and returns either a normal completion
containingunused or a throw
completion. It allocates and associates an ArrayBuffer with
O. It performs the following steps when called:
does not have a [[ViewedArrayBuffer]] or any other of the internal
slots that are specific to TypedArray instance objects.
23.2.7.1TypedArray.prototype.BYTES_PER_ELEMENT
The value of TypedArray.prototype.BYTES_PER_ELEMENT is the Element
Size value specified in Table 75 for
TypedArray.
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
23.2.7.2TypedArray.prototype.constructor
The initial value of the "constructor" property of the prototype for a
given TypedArrayconstructor is the constructor itself.
23.2.8 Properties of TypedArray Instances
TypedArray instances are TypedArrays. Each TypedArray instance
inherits properties from the corresponding TypedArray prototype object. Each
TypedArray instance has the following internal slots: [[ViewedArrayBuffer]], [[TypedArrayName]], [[ContentType]], [[ByteLength]], [[ByteOffset]], and [[ArrayLength]].
24 Keyed Collections
24.1 Map Objects
Maps are collections of key/value pairs where both the keys and values may be arbitrary ECMAScript language values. A distinct
key value may only occur in one key/value pair within the Map's collection. Distinct key values are
discriminated using the semantics of the SameValueZero comparison algorithm.
Maps must be implemented using either hash tables or other mechanisms that, on average, provide
access times that are sublinear on the number of elements in the collection. The data structure used
in this specification is only intended to describe the required observable semantics of Maps. It is
not intended to be a viable implementation model.
is the initial value of the "Map" property of the global
object.
creates and initializes a new Map when called as a constructor.
is not intended to be called as a function and will throw an exception when called in that
manner.
may be used as the value in an extends clause of a class definition. Subclass
constructors that intend to inherit the specified
Map behaviour must include a super call to the Map constructor to
create and initialize the subclass instance with the internal state necessary to support the
Map.prototype built-in methods.
24.1.1.1 Map ( [ iterable ] )
This function performs the following steps when called:
If NewTarget is undefined, throw a TypeError
exception.
If the parameter iterable is present, it is expected to be an object that
implements a %Symbol.iterator% method that
returns an iterator object that produces
a two element array-like object whose first
element is a value that will be used as a Map key and whose second element is the
value to associate with that key.
The parameter iterable is expected to be an object that implements a
%Symbol.iterator% method that
returns an iterator object that produces
a two element array-like object whose first
element is a value that will be used as a Map key and whose second element is the
value to associate with that key.
callback should be a function that accepts two arguments.
groupBy calls callback once for each element in
items, in ascending order, and constructs a new Map. Each value returned
by callback is used as a key in the Map. For each such key, the result
Map has an entry whose key is that key and whose value is an array containing all
the elements for which callback returned that key.
callback is called with two arguments: the value of the element and the
index of the element.
The return value of groupBy is a Map.
This function performs the following steps when called:
Let groups be ? GroupBy(items,
callback, collection).
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
24.1.2.3 get Map [ %Symbol.species% ]
Map[%Symbol.species%] is an accessor property whose set accessor function
is undefined. Its get accessor function performs the following steps when
called:
Return the this value.
The value of the "name" property of this function is "get
[Symbol.species]".
For each Record { [[Key]], [[Value]] }
p of M.[[MapData]], do
Set p.[[Key]] to
empty.
Set p.[[Value]] to
empty.
Return undefined.
Note
The existing [[MapData]]List is
preserved because there may be existing Map Iterator
objects that are suspended midway through iterating over that
List.
24.1.3.2 Map.prototype.constructor
The initial value of Map.prototype.constructor is %Map%.
24.1.3.3 Map.prototype.delete ( key )
This method performs the following steps when called:
For each Record { [[Key]], [[Value]] }
p of M.[[MapData]], do
If p.[[Key]] is not
empty and SameValue(p.[[Key]], key) is true,
then
Set p.[[Key]] to
empty.
Set p.[[Value]] to
empty.
Return true.
Return false.
Note
The value empty is used as a specification device to indicate
that an entry has been deleted. Actual implementations may take other actions such
as physically removing the entry from internal data structures.
24.1.3.4 Map.prototype.entries ( )
This method performs the following steps when called:
If IsCallable(callback) is
false, throw a TypeError exception.
Let entries be M.[[MapData]].
Let numEntries be the number of elements in entries.
Let index be 0.
Repeat, while index < numEntries,
Let e be entries[index].
Set index to index + 1.
If e.[[Key]] is not
empty, then
Perform ? Call(callback,
thisArg, « e.[[Value]], e.[[Key]], M »).
NOTE: The number of elements in entries may have
increased during execution of callback.
Set numEntries to the number of elements in
entries.
Return undefined.
Note
callback should be a function that accepts three arguments.
forEach calls callback once for each key/value pair present
in the Map, in key insertion order. callback is called only for keys of
the Map which actually exist; it is not called for keys that have been deleted from
the Map.
If a thisArg parameter is provided, it will be used as the
this value for each invocation of callback. If it is
not provided, undefined is used instead.
callback is called with three arguments: the value of the item, the key of
the item, and the Map being traversed.
forEach does not directly mutate the object on which it is called but
the object may be mutated by the calls to callback. Each entry of a map's
[[MapData]] is only visited once. New keys added after the
call to forEach begins are visited. A key will be revisited if it is
deleted after it has been visited and then re-added before the forEach
call completes. Keys that are deleted after the call to forEach begins
and before being visited are not visited unless the key is added again before the
forEach call completes.
24.1.3.6 Map.prototype.get ( key )
This method performs the following steps when called:
For each Record { [[Key]], [[Value]] }
p of M.[[MapData]], do
If p.[[Key]] is not
empty and SameValue(p.[[Key]], key) is true,
then
Set p.[[Value]] to
value.
Return M.
Let p be the Record { [[Key]]: key, [[Value]]:
value }.
Append p to M.[[MapData]].
Return M.
24.1.3.10 get Map.prototype.size
Map.prototype.size is an accessor property whose set accessor function
is undefined. Its get accessor function performs the following steps when
called:
A Map
Iterator is an object that represents a specific iteration over some specific Map
instance object. There is not a named constructor for Map Iterator objects. Instead, Map
Iterator objects are created by calling certain methods of Map instance objects.
The initial value of the %Symbol.toStringTag% property is
the String value "Map Iterator".
This property has the attributes { [[Writable]]:
false, [[Enumerable]]:
false, [[Configurable]]:
true }.
24.2 Set Objects
Set objects are collections of ECMAScript language values. A distinct
value may only occur once as an element of a Set's collection. Distinct values are discriminated
using the semantics of the SameValueZero comparison algorithm.
Set objects must be implemented using either hash tables or other mechanisms that, on average,
provide access times that are sublinear on the number of elements in the collection. The data
structure used in this specification is only intended to describe the required observable semantics
of Set objects. It is not intended to be a viable implementation model.
24.2.1 Abstract Operations For Set Objects
24.2.1.1 Set Records
A Set Record is a Record value used to
encapsulate the interface of a Set or similar object.
If IsCallable(keys) is
false, throw a TypeError exception.
Return a new Set Record { [[SetObject]]: obj, [[Size]]: intSize, [[Has]]: has, [[Keys]]:
keys }.
24.2.1.3 SetDataHas ( setData, value )
The abstract operation SetDataHas takes arguments setData (a List of either
ECMAScript language values or
empty) and value (an ECMAScript language value) and
returns a Boolean. It performs the following steps when called:
If SetDataIndex(setData,
value) is not-found, return
false.
Return true.
24.2.1.4 SetDataIndex ( setData, value )
The abstract operation SetDataIndex takes arguments setData (a List of either
ECMAScript language values or
empty) and value (an ECMAScript language value) and
returns a non-negative integer or not-found. It
performs the following steps when called:
The abstract operation SetDataSize takes argument setData (a List of either
ECMAScript language values or
empty) and returns a non-negative integer. It performs the following
steps when called:
is the initial value of the "Set" property of the global
object.
creates and initializes a new Set object when called as a constructor.
is not intended to be called as a function and will throw an exception when called in that
manner.
may be used as the value in an extends clause of a class definition. Subclass
constructors that intend to inherit the specified
Set behaviour must include a super call to the Set constructor to
create and initialize the subclass instance with the internal state necessary to support the
Set.prototype built-in methods.
24.2.2.1 Set ( [ iterable ] )
This function performs the following steps when called:
If NewTarget is undefined, throw a TypeError
exception.
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
24.2.3.2 get Set [ %Symbol.species% ]
Set[%Symbol.species%] is an accessor property whose set accessor function
is undefined. Its get accessor function performs the following steps when
called:
Return the this value.
The value of the "name" property of this function is "get
[Symbol.species]".
Replace the element of S.[[SetData]]
whose value is e with an element whose value is
empty.
Return undefined.
Note
The existing [[SetData]]List is
preserved because there may be existing Set Iterator
objects that are suspended midway through iterating over that
List.
24.2.4.3 Set.prototype.constructor
The initial value of Set.prototype.constructor is %Set%.
24.2.4.4 Set.prototype.delete ( value )
This method performs the following steps when called:
If e is not empty and SameValue(e,
value) is true, then
Replace the element of S.[[SetData]] whose value is e with
an element whose value is empty.
Return true.
Return false.
Note
The value empty is used as a specification device to indicate
that an entry has been deleted. Actual implementations may take other actions such
as physically removing the entry from internal data structures.
24.2.4.5 Set.prototype.difference ( other )
This method performs the following steps when called:
NOTE: The number of elements in entries may have
increased during execution of callback.
Set numEntries to the number of elements in
entries.
Return undefined.
Note
callback should be a function that accepts three arguments.
forEach calls callback once for each value present in the
Set object, in value insertion order. callback is called only for values
of the Set which actually exist; it is not called for keys that have been deleted
from the set.
If a thisArg parameter is provided, it will be used as the
this value for each invocation of callback. If it is
not provided, undefined is used instead.
callback is called with three arguments: the first two arguments are a
value contained in the Set. The same value is passed for both arguments. The Set
object being traversed is passed as the third argument.
The callback is called with three arguments to be consistent with the call
back functions used by forEach methods for Map and Array. For Sets,
each item value is considered to be both the key and the value.
forEach does not directly mutate the object on which it is called but
the object may be mutated by the calls to callback.
Each value is normally visited only once. However, a value will be revisited if it is
deleted after it has been visited and then re-added before the forEach
call completes. Values that are deleted after the call to forEach
begins and before being visited are not visited unless the value is added again
before the forEach call completes. New values added after the call to
forEach begins are visited.
24.2.4.8 Set.prototype.has ( value )
This method performs the following steps when called:
If SetDataSize(O.[[SetData]]) ≤ otherRec.[[Size]], then
Let thisSize be the number of elements in O.[[SetData]].
Let index be 0.
Repeat, while index < thisSize,
Let e be O.[[SetData]][index].
Set index to index + 1.
If e is not empty, then
Let inOther be ToBoolean(?
Call(otherRec.[[Has]], otherRec.[[SetObject]], «
e »)).
If inOther is true, then
NOTE: It is possible for earlier calls to
otherRec.[[Has]]
to remove and re-add an element of O.[[SetData]], which can cause
the same element to be visited twice during this
iteration.
The initial value of the "keys" property is %Set.prototype.values%,
defined in 24.2.4.17.
Note
For iteration purposes, a Set appears similar to a Map where each entry has the same
value for its key and value.
24.2.4.14 get Set.prototype.size
Set.prototype.size is an accessor property whose set accessor function
is undefined. Its get accessor function performs the following steps when
called:
A Set
Iterator is an ordinary object, with the structure defined
below, that represents a specific iteration over some specific Set instance object. There is not
a named constructor for Set Iterator objects. Instead, Set
Iterator objects are created by calling certain methods of Set instance objects.
The initial value of the %Symbol.toStringTag% property is
the String value "Set Iterator".
This property has the attributes { [[Writable]]:
false, [[Enumerable]]:
false, [[Configurable]]:
true }.
24.3 WeakMap Objects
WeakMaps are collections of key/value pairs where the keys are objects and/or symbols and values may
be arbitrary ECMAScript language values. A WeakMap
may be queried to see if it contains a key/value pair with a specific key, but no mechanism is
provided for enumerating the values it holds as keys. In certain conditions, values which are not
live are
removed as WeakMap keys, as described in 9.9.3.
An implementation may impose an arbitrarily determined latency between the time a key/value pair of a
WeakMap becomes inaccessible and the time when the key/value pair is removed from the WeakMap. If
this latency was observable to ECMAScript program, it would be a source of indeterminacy that could
impact program execution. For that reason, an ECMAScript implementation must not provide any means
to observe a key of a WeakMap that does not require the observer to present the observed key.
WeakMaps must be implemented using either hash tables or other mechanisms that, on average, provide
access times that are sublinear on the number of key/value pairs in the collection. The data
structure used in this specification is only intended to describe the required observable semantics
of WeakMaps. It is not intended to be a viable implementation model.
Note
WeakMap and WeakSet are intended to provide mechanisms for dynamically associating state with
an object or symbol in a manner that does not “leak” memory resources if, in the absence of
the WeakMap or WeakSet instance, the object or symbol otherwise became inaccessible and
subject to resource reclamation by the implementation's garbage collection mechanisms. This
characteristic can be achieved by using an inverted per-object/symbol mapping of WeakMap or
WeakSet instances to keys. Alternatively, each WeakMap or WeakSet instance may internally
store its key and value data, but this approach requires coordination between the WeakMap or
WeakSet implementation and the garbage collector. The following references describe
mechanism that may be useful to implementations of WeakMap and WeakSet:
Barry Hayes. 1997. Ephemerons: a new finalization mechanism. In Proceedings of the 12th
ACM SIGPLAN conference on Object-oriented programming, systems, languages, and
applications (OOPSLA '97), A. Michael Berman (Ed.). ACM, New York, NY, USA, 176-183,
http://doi.acm.org/10.1145/263698.263733.
is the initial value of the "WeakMap" property of the global
object.
creates and initializes a new WeakMap when called as a constructor.
is not intended to be called as a function and will throw an exception when called in that
manner.
may be used as the value in an extends clause of a class definition. Subclass
constructors that intend to inherit the specified
WeakMap behaviour must include a super call to the WeakMap constructor to
create and initialize the subclass instance with the internal state necessary to support the
WeakMap.prototype built-in methods.
24.3.1.1 WeakMap ( [ iterable ] )
This function performs the following steps when called:
If NewTarget is undefined, throw a TypeError
exception.
If the parameter iterable is present, it is expected to be an object that
implements a %Symbol.iterator% method that
returns an iterator object that produces
a two element array-like object whose first
element is a value that will be used as a WeakMap key and whose second element is
the value to associate with that key.
For each Record { [[Key]], [[Value]] }
p of M.[[WeakMapData]], do
If p.[[Key]] is not
empty and SameValue(p.[[Key]], key) is true,
then
Set p.[[Key]] to
empty.
Set p.[[Value]] to
empty.
Return true.
Return false.
Note
The value empty is used as a specification device to indicate
that an entry has been deleted. Actual implementations may take other actions such
as physically removing the entry from internal data structures.
24.3.3.3 WeakMap.prototype.get ( key )
This method performs the following steps when called:
WeakSets are collections of objects and/or symbols. A distinct object or symbol may only occur once
as an element of a WeakSet's collection. A WeakSet may be queried to see if it contains a specific
value, but no mechanism is provided for enumerating the values it holds. In certain conditions,
values which are not live are removed as WeakSet elements, as described in
9.9.3.
An implementation may impose an arbitrarily determined latency between the time a value contained in
a WeakSet becomes inaccessible and the time when the value is removed from the WeakSet. If this
latency was observable to ECMAScript program, it would be a source of indeterminacy that could
impact program execution. For that reason, an ECMAScript implementation must not provide any means
to determine if a WeakSet contains a particular value that does not require the observer to present
the observed value.
WeakSets must be implemented using either hash tables or other mechanisms that, on average, provide
access times that are sublinear on the number of elements in the collection. The data structure used
in this specification is only intended to describe the required observable semantics of WeakSets. It
is not intended to be a viable implementation model.
is the initial value of the "WeakSet" property of the global
object.
creates and initializes a new WeakSet when called as a constructor.
is not intended to be called as a function and will throw an exception when called in that
manner.
may be used as the value in an extends clause of a class definition. Subclass
constructors that intend to inherit the specified
WeakSet behaviour must include a super call to the WeakSet constructor to
create and initialize the subclass instance with the internal state necessary to support the
WeakSet.prototype built-in methods.
24.4.1.1 WeakSet ( [ iterable ] )
This function performs the following steps when called:
If NewTarget is undefined, throw a TypeError
exception.
If e is not empty and SameValue(e,
value) is true, then
Replace the element of S.[[WeakSetData]] whose value is e
with an element whose value is empty.
Return true.
Return false.
Note
The value empty is used as a specification device to indicate
that an entry has been deleted. Actual implementations may take other actions such
as physically removing the entry from internal data structures.
24.4.3.4 WeakSet.prototype.has ( value )
This method performs the following steps when called:
The descriptions below in this section, 25.4, and 29 use the read-modify-write
modification function internal data structure.
A read-modify-write
modification function is a mathematical function that is represented as an abstract
closure that takes two Lists of
byte
values as arguments and returns a List of byte
values. These abstract closures satisfy all of the following properties:
They perform all their algorithm steps atomically.
Their individual algorithm steps are not observable.
Note
To aid verifying that a read-modify-write modification function's algorithm steps
constitute a pure, mathematical function, the following editorial conventions are
recommended:
They do not access, directly or transitively via invoked abstract
operations and abstract closures, any language or
specification values except their parameters and captured values.
The abstract operation AllocateArrayBuffer takes arguments constructor (a
constructor) and byteLength (a
non-negative integer) and optional argument
maxByteLength (a non-negative integer or empty) and returns
either a normal completion
containing an ArrayBuffer or a throw completion. It
is used to create an ArrayBuffer. It performs the following steps when called:
Let slots be « [[ArrayBufferData]], [[ArrayBufferByteLength]], [[ArrayBufferDetachKey]] ».
If maxByteLength is present and maxByteLength is not
empty, let allocatingResizableBuffer be
true; otherwise let allocatingResizableBuffer be
false.
If allocatingResizableBuffer is true, then
If byteLength > maxByteLength, throw a
RangeError exception.
If it is not possible to create a Data Blockblock consisting of maxByteLength bytes, throw a
RangeError exception.
NOTE: Resizable ArrayBuffers are designed to be implementable with in-place
growth. Implementations may throw if, for example, virtual memory cannot be
reserved up front.
Set obj.[[ArrayBufferMaxByteLength]] to
maxByteLength.
Return obj.
25.1.3.2 ArrayBufferByteLength ( arrayBuffer,
order )
The abstract operation ArrayBufferByteLength takes arguments arrayBuffer (an
ArrayBuffer or SharedArrayBuffer) and order (seq-cst or
unordered) and returns a non-negative integer. It performs the following
steps when called:
If IsSharedArrayBuffer(arrayBuffer)
is true and arrayBuffer has an [[ArrayBufferByteLengthData]] internal slot, then
Let bufferByteLengthBlock be arrayBuffer.[[ArrayBufferByteLengthData]].
NOTE: Neither creation of the new Data Block nor copying
from the old Data Block are observable.
Implementations may implement this method as a zero-copy move or a
realloc.
The abstract operation IsDetachedBuffer takes argument arrayBuffer (an ArrayBuffer
or a SharedArrayBuffer) and returns a Boolean. It performs the following steps when called:
If arrayBuffer.[[ArrayBufferData]] is
null, return true.
The abstract operation DetachArrayBuffer takes argument arrayBuffer (an
ArrayBuffer) and optional argument key (anything) and returns either a normal completion
containingunused or a throw completion. It
performs the following steps when called:
If arrayBuffer.[[ArrayBufferDetachKey]] is not
key, throw a TypeError exception.
Set arrayBuffer.[[ArrayBufferData]] to
null.
Set arrayBuffer.[[ArrayBufferByteLength]] to 0.
Return unused.
Note
Detaching an ArrayBuffer instance disassociates the Data Block used as its
backing store from the instance and sets the byte length of the buffer to 0.
The abstract operation CloneArrayBuffer takes arguments srcBuffer (an ArrayBuffer
or a SharedArrayBuffer), srcByteOffset (a non-negative integer), and srcLength (a
non-negative integer) and returns either a normal completion
containing an ArrayBuffer or a throw completion. It
creates a new ArrayBuffer whose data is a copy of srcBuffer's data over the range
starting at srcByteOffset and continuing for srcLength bytes. It
performs the following steps when called:
The host-defined abstract operation
HostResizeArrayBuffer takes arguments buffer (an ArrayBuffer) and
newByteLength (a non-negative integer) and returns either a normal completion
containing either handled or
unhandled, or a throw completion. It
gives the host an
opportunity to perform implementation-defined resizing of
buffer. If the host chooses not to handle resizing of
buffer, it may return unhandled for the default behaviour.
The implementation of HostResizeArrayBuffer must conform to the following requirements:
The abstract operation does not detach buffer.
If the abstract operation completes normally with handled,
buffer.[[ArrayBufferByteLength]] is
newByteLength.
The default implementation of HostResizeArrayBuffer is to return NormalCompletion(unhandled).
25.1.3.9 IsFixedLengthArrayBuffer ( arrayBuffer )
The abstract operation IsFixedLengthArrayBuffer takes argument arrayBuffer (an
ArrayBuffer or a SharedArrayBuffer) and returns a Boolean. It performs the following steps
when called:
If arrayBuffer has an [[ArrayBufferMaxByteLength]] internal slot, return
false.
Return true.
25.1.3.10 IsUnsignedElementType ( type )
The abstract operation IsUnsignedElementType takes argument type (a TypedArray element type) and returns a
Boolean. It verifies if the argument type is an unsigned TypedArray element type. It performs
the following steps when called:
If type is one of uint8,
uint8clamped, uint16,
uint32, or biguint64, return
true.
Return false.
25.1.3.11 IsUnclampedIntegerElementType ( type )
The abstract operation IsUnclampedIntegerElementType takes argument type (a
TypedArray element type) and returns a
Boolean. It verifies if the argument type is an IntegerTypedArray element type not including
uint8clamped. It performs the following steps when called:
If type is one of int8,
uint8, int16,
uint16, int32, or
uint32, return true.
If type is either biguint64 or
bigint64, return true.
Return false.
25.1.3.13 IsNoTearConfiguration ( type,
order )
The abstract operation IsNoTearConfiguration takes arguments type (a TypedArray element type) and
order (seq-cst, unordered, or
init) and returns a Boolean. It performs the following steps when
called:
The abstract operation RawBytesToNumeric takes arguments type (a TypedArray element type),
rawBytes (a List of
byte
values), and isLittleEndian (a Boolean) and returns a
Number or a BigInt. It performs the following steps when called:
Let elementSize be the Element Size value specified in Table 75 for
Element Type type.
If isLittleEndian is false, reverse the order of the
elements of rawBytes.
If type is float16, then
Let value be the byte elements of rawBytes
concatenated and interpreted as a little-endian bit string encoding of an
IEEE 754-2019 binary16
value.
If value is a NaN, return NaN.
Return the Number value that corresponds to value.
If type is float32, then
Let value be the byte elements of rawBytes
concatenated and interpreted as a little-endian bit string encoding of an
IEEE 754-2019 binary32
value.
If value is a NaN, return NaN.
Return the Number value that corresponds to value.
If type is float64, then
Let value be the byte elements of rawBytes
concatenated and interpreted as a little-endian bit string encoding of an
IEEE 754-2019 binary64
value.
If value is a NaN, return NaN.
Return the Number value that corresponds to value.
Let intValue be the byte elements of rawBytes
concatenated and interpreted as a bit string encoding of an unsigned
little-endian binary number.
Else,
Let intValue be the byte elements of rawBytes
concatenated and interpreted as a bit string encoding of a binary
little-endian two's complement number of bit length elementSize ×
8.
If IsBigIntElementType(type)
is true, return the BigInt value that corresponds to
intValue.
Otherwise, return the Number value that corresponds to intValue.
25.1.3.15 GetRawBytesFromSharedBlock ( block,
byteIndex, type, isTypedArray, order )
The abstract operation GetRawBytesFromSharedBlock takes arguments block (a
Shared Data
Block), byteIndex (a non-negative integer),
type (a TypedArray element type),
isTypedArray (a Boolean), and order (seq-cst or
unordered) and returns a List of byte
values. It performs the following steps when called:
Let elementSize be the Element Size value specified in Table 75 for
Element Type type.
If isTypedArray is true and IsNoTearConfiguration(type,
order) is true, let noTear be
true; otherwise let noTear be
false.
Let rawValue be a List of length
elementSize whose elements are nondeterministically chosen byte
values.
NOTE: In implementations, rawValue is the result of a non-atomic or
atomic read instruction on the underlying hardware. The nondeterminism is a semantic
prescription of the memory model to describe observable
behaviour of hardware with weak consistency.
Let readEvent be ReadSharedMemory { [[Order]]: order, [[NoTear]]: noTear, [[Block]]: block, [[ByteIndex]]: byteIndex, [[ElementSize]]: elementSize }.
Append readEvent to eventsRecord.[[EventList]].
Append Chosen Value Record { [[Event]]: readEvent, [[ChosenValue]]: rawValue } to
execution.[[ChosenValues]].
The abstract operation GetValueFromBuffer takes arguments arrayBuffer (an
ArrayBuffer or SharedArrayBuffer), byteIndex (a non-negative integer),
type (a TypedArray element type),
isTypedArray (a Boolean), and order (seq-cst or
unordered) and optional argument isLittleEndian (a
Boolean) and returns a Number or a BigInt. It performs the following steps when called:
Let rawValue be a List
whose elements are bytes from block at indices in the interval from byteIndex
(inclusive) to byteIndex + elementSize (exclusive).
Assert:
The number of elements in rawValue is elementSize.
If isLittleEndian is not present, set isLittleEndian to the
value of the [[LittleEndian]] field of the surrounding agent's Agent
Record.
The abstract operation NumericToRawBytes takes arguments type (a TypedArray element type),
value (a Number or a BigInt), and isLittleEndian (a Boolean) and
returns a List of byte
values. It performs the following steps when called:
If type is float16, then
Let rawBytes be a List
whose elements are the 2 bytes that are the result of converting
value to IEEE 754-2019 binary16
format using roundTiesToEven mode. The bytes are arranged in little endian
order. If value is NaN, rawBytes
may be set to any implementation chosen IEEE 754-2019
binary16 format NaN encoding. An implementation must always choose the same
encoding for each implementation distinguishable NaN
value.
Else if type is float32, then
Let rawBytes be a List
whose elements are the 4 bytes that are the result of converting
value to IEEE 754-2019 binary32
format using roundTiesToEven mode. The bytes are arranged in little endian
order. If value is NaN, rawBytes
may be set to any implementation chosen IEEE 754-2019
binary32 format NaN encoding. An implementation must always choose the same
encoding for each implementation distinguishable NaN
value.
Else if type is float64, then
Let rawBytes be a List
whose elements are the 8 bytes that are the IEEE 754-2019 binary64
format encoding of value. The bytes are arranged in little endian
order. If value is NaN, rawBytes
may be set to any implementation chosen IEEE 754-2019
binary64 format NaN encoding. An implementation must always choose the same
encoding for each implementation distinguishable NaN
value.
Else,
Let n be the Element Size value specified in Table 75
for Element Type type.
Let conversionOperation be the abstract operation named in the
Conversion Operation column in Table 75
for Element Type type.
The abstract operation SetValueInBuffer takes arguments arrayBuffer (an
ArrayBuffer or SharedArrayBuffer), byteIndex (a non-negative integer),
type (a TypedArray element type),
value (a Number or a BigInt), isTypedArray (a Boolean), and
order (seq-cst, unordered, or
init) and optional argument isLittleEndian (a Boolean) and
returns unused. It performs the following steps when called:
Store the individual bytes of rawBytes into block,
starting at block[byteIndex].
Return unused.
25.1.3.19 GetModifySetValueInBuffer ( arrayBuffer,
byteIndex, type, value, op )
The abstract operation GetModifySetValueInBuffer takes arguments arrayBuffer (an
ArrayBuffer or a SharedArrayBuffer), byteIndex (a non-negative integer),
type (a TypedArray element type),
value (a Number or a BigInt), and op (a read-modify-write modification
function) and returns a Number or a BigInt. It performs the following
steps when called:
Let rawBytesRead be a List
of length elementSize whose elements are nondeterministically
chosen byte values.
NOTE: In implementations, rawBytesRead is the result of a
load-link, of a load-exclusive, or of an operand of a read-modify-write
instruction on the underlying hardware. The nondeterminism is a semantic
prescription of the memory model to describe
observable behaviour of hardware with weak consistency.
Let rmwEvent be ReadModifyWriteSharedMemory
{ [[Order]]: seq-cst, [[NoTear]]: true, [[Block]]: block, [[ByteIndex]]: byteIndex, [[ElementSize]]: elementSize, [[Payload]]: rawBytes, [[ModifyOp]]: op }.
Append rmwEvent to eventsRecord.[[EventList]].
Append Chosen Value Record
{ [[Event]]: rmwEvent, [[ChosenValue]]: rawBytesRead } to
execution.[[ChosenValues]].
Else,
Let rawBytesRead be a List
of length elementSize whose elements are the sequence of
elementSize bytes starting with
block[byteIndex].
Let rawBytesModified be op(rawBytesRead,
rawBytes).
Store the individual bytes of rawBytesModified into
block, starting at block[byteIndex].
is the initial value of the "ArrayBuffer" property of the global
object.
creates and initializes a new ArrayBuffer when called as a constructor.
is not intended to be called as a function and will throw an exception when called in that
manner.
may be used as the value of an extends clause of a class definition. Subclass
constructors that intend to inherit the specified
ArrayBuffer behaviour must include a super call to the ArrayBuffer constructor to
create and initialize subclass instances with the internal state necessary to support the
ArrayBuffer.prototype built-in methods.
25.1.4.1 ArrayBuffer ( length [ , options
] )
This function performs the following steps when called:
If NewTarget is undefined, throw a TypeError
exception.
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
25.1.5.3 get ArrayBuffer [ %Symbol.species% ]
ArrayBuffer[%Symbol.species%] is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
Return the this value.
The value of the "name" property of this function is "get
[Symbol.species]".
does not have an [[ArrayBufferData]] or [[ArrayBufferByteLength]] internal slot.
25.1.6.1 get ArrayBuffer.prototype.byteLength
ArrayBuffer.prototype.byteLength is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
The initial value of ArrayBuffer.prototype.constructor is %ArrayBuffer%.
25.1.6.3 get ArrayBuffer.prototype.detached
ArrayBuffer.prototype.detached is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
ArrayBuffer.prototype.maxByteLength is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
ArrayBuffer.prototype.resizable is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
NOTE: Neither creation of the new Data Block nor copying
from the old Data Block are observable.
Implementations may implement this method as in-place growth or shrinkage.
Set O.[[ArrayBufferData]] to
newBlock.
Set O.[[ArrayBufferByteLength]] to
newByteLength.
Return undefined.
25.1.6.7 ArrayBuffer.prototype.slice ( start,
end )
This method performs the following steps when called:
The initial value of the %Symbol.toStringTag% property is the
String value "ArrayBuffer".
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: true }.
25.1.7 Properties of ArrayBuffer Instances
ArrayBuffer instances inherit properties from the ArrayBuffer prototype
object. ArrayBuffer instances each have an [[ArrayBufferData]] internal slot, an [[ArrayBufferByteLength]] internal slot, and an [[ArrayBufferDetachKey]] internal slot. ArrayBuffer instances which are
resizable each have an [[ArrayBufferMaxByteLength]] internal slot.
ArrayBuffer instances whose [[ArrayBufferData]] is
null are considered to be detached and all operators to access or modify data
contained in the ArrayBuffer instance will fail.
ArrayBuffer instances whose [[ArrayBufferDetachKey]] is set to a value
other than undefined need to have all DetachArrayBuffer calls
passing that same "detach key" as an argument, otherwise a TypeError will result. This internal
slot is only ever set by certain embedding environments, not by algorithms in this
specification.
25.1.8 Resizable ArrayBuffer Guidelines
Note 1
The following are guidelines for ECMAScript programmers working with resizable
ArrayBuffer.
We recommend that programs be tested in their deployment environments where possible. The
amount of available physical memory differs greatly between hardware devices. Similarly,
virtual memory subsystems also differ greatly between hardware devices as well as
operating systems. An application that runs without out-of-memory errors on a 64-bit
desktop web browser could run out of memory on a 32-bit mobile web browser.
When choosing a value for the "maxByteLength" option for resizable
ArrayBuffer, we recommend that the smallest possible size for the
application be chosen. We recommend that "maxByteLength" does not
exceed 1,073,741,824 (230 bytes or 1GiB).
Please note that successfully constructing a resizable
ArrayBuffer for a particular maximum size does not guarantee that
future resizes will succeed.
Note 2
The following are guidelines for ECMAScript implementers implementing resizable
ArrayBuffer.
Resizable
ArrayBuffer can be implemented as copying upon resize, as
in-place growth via reserving virtual memory up front, or as a combination of both for
different values of the constructor's
"maxByteLength" option.
If a host is
multi-tenanted (i.e. it runs many ECMAScript applications simultaneously), such as a web
browser, and its implementations choose to implement in-place growth by reserving
virtual memory, we recommend that both 32-bit and 64-bit implementations throw for
values of "maxByteLength" ≥ 1GiB to 1.5GiB. This is to reduce the
likelihood a single application can exhaust the virtual memory address space and to
reduce interoperability risk.
If a host does not
have virtual memory, such as those running on embedded devices without an MMU, or if a
host only
implements resizing by copying, it may accept any Number value
for the "maxByteLength" option. However, we
recommend a RangeError be thrown if a memory block of the requested
size can never be allocated. For example, if the requested size is greater than the
maximum amount of usable memory on the device.
25.2 SharedArrayBuffer Objects
25.2.1 Fixed-length and Growable SharedArrayBuffer Objects
A fixed-length SharedArrayBuffer is a SharedArrayBuffer whose byte
length cannot change after creation.
The abstract operation AllocateSharedArrayBuffer takes arguments constructor (a
constructor) and byteLength (a
non-negative integer) and optional argument
maxByteLength (a non-negative integer or empty) and returns
either a normal completion
containing a SharedArrayBuffer or a throw completion. It
is used to create a SharedArrayBuffer. It performs the following steps when called:
Let slots be « [[ArrayBufferData]] ».
If maxByteLength is present and maxByteLength is not
empty, let allocatingGrowableBuffer be
true; otherwise let allocatingGrowableBuffer be
false.
If allocatingGrowableBuffer is true, then
If byteLength > maxByteLength, throw a
RangeError exception.
Append [[ArrayBufferByteLengthData]] and [[ArrayBufferMaxByteLength]] to slots.
Set obj.[[ArrayBufferByteLengthData]] to
byteLengthBlock.
Set obj.[[ArrayBufferMaxByteLength]] to
maxByteLength.
Else,
Set obj.[[ArrayBufferByteLength]] to
byteLength.
Return obj.
25.2.2.2 IsSharedArrayBuffer ( obj )
The abstract operation IsSharedArrayBuffer takes argument obj (an ArrayBuffer or a
SharedArrayBuffer) and returns a Boolean. It tests whether an object is an ArrayBuffer, a
SharedArrayBuffer, or a subtype of either. It performs the following steps when called:
The host-defined abstract operation
HostGrowSharedArrayBuffer takes arguments buffer (a SharedArrayBuffer) and
newByteLength (a non-negative integer) and returns either a normal completion
containing either handled or
unhandled, or a throw completion. It
gives the host an
opportunity to perform implementation-defined growing of
buffer. If the host chooses not to handle growing of buffer,
it may return unhandled for the default behaviour.
The implementation of HostGrowSharedArrayBuffer must conform to the following requirements:
If the abstract operation does not complete normally with
unhandled, and newByteLength < the current byte
length of the buffer or newByteLength > buffer.[[ArrayBufferMaxByteLength]], throw a
RangeError exception.
Let isLittleEndian be the value of the [[LittleEndian]] field of the surrounding
agent's Agent Record. If the abstract operation
completes normally with handled, a WriteSharedMemory or
ReadModifyWriteSharedMemory
event whose [[Order]] is seq-cst, [[Payload]] is NumericToRawBytes(biguint64,
newByteLength, isLittleEndian), [[Block]]
is buffer.[[ArrayBufferByteLengthData]], [[ByteIndex]] is 0, and [[ElementSize]]
is 8 is added to the surrounding agent's candidate execution such that
racing calls to SharedArrayBuffer.prototype.grow are not "lost", i.e.
silently do nothing.
Note
The second requirement above is intentionally vague about how or when the current
byte length of buffer is read. Because the byte length must be updated
via an atomic read-modify-write operation on the underlying hardware, architectures
that use load-link/store-conditional or load-exclusive/store-exclusive instruction
pairs may wish to keep the paired instructions close in the instruction stream. As
such, SharedArrayBuffer.prototype.grow itself does not perform bounds checking on
newByteLength before calling HostGrowSharedArrayBuffer, nor is there a
requirement on when the current byte length is read.
This is in contrast with HostResizeArrayBuffer,
which is guaranteed that the value of newByteLength is ≥ 0 and ≤
buffer.[[ArrayBufferMaxByteLength]].
The default implementation of HostGrowSharedArrayBuffer is to return NormalCompletion(unhandled).
is the initial value of the "SharedArrayBuffer" property of the global
object, if that property is present (see below).
creates and initializes a new SharedArrayBuffer when called as a constructor.
is not intended to be called as a function and will throw an exception when called in that
manner.
may be used as the value of an extends clause of a class definition. Subclass
constructors that intend to inherit the specified
SharedArrayBuffer behaviour must include a super call to the SharedArrayBuffer
constructor to create and initialize subclass
instances with the internal state necessary to support the
SharedArrayBuffer.prototype built-in methods.
Whenever a host does not
provide concurrent access to SharedArrayBuffers it may omit the
"SharedArrayBuffer" property of the global object.
Note
Unlike an ArrayBuffer, a SharedArrayBuffer cannot become
detached, and its internal [[ArrayBufferData]] slot is never
null.
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
25.2.4.2 get SharedArrayBuffer [ %Symbol.species% ]
SharedArrayBuffer[%Symbol.species%] is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
Return the this value.
The value of the "name" property of this function is "get
[Symbol.species]".
25.2.5 Properties of the SharedArrayBuffer Prototype Object
does not have an [[ArrayBufferData]] or [[ArrayBufferByteLength]] internal slot.
25.2.5.1 get SharedArrayBuffer.prototype.byteLength
SharedArrayBuffer.prototype.byteLength is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
Let byteLengthBlock be O.[[ArrayBufferByteLengthData]].
Let currentByteLengthRawBytes be GetRawBytesFromSharedBlock(byteLengthBlock,
0, biguint64, true,
seq-cst).
Let newByteLengthRawBytes be NumericToRawBytes(biguint64,
ℤ(newByteLength),
isLittleEndian).
Repeat,
NOTE: This is a compare-and-exchange loop to ensure that parallel, racing
grows of the same buffer are totally ordered, are not lost, and do not
silently do nothing. The loop exits if it was able to attempt to grow
uncontended.
Let currentByteLength be ℝ(RawBytesToNumeric(biguint64,
currentByteLengthRawBytes, isLittleEndian)).
If newByteLength = currentByteLength, return
undefined.
If newByteLength < currentByteLength or
newByteLength > O.[[ArrayBufferMaxByteLength]], throw a
RangeError exception.
Let byteLengthDelta be newByteLength -
currentByteLength.
If it is impossible to create a new Shared Data
Block value consisting of byteLengthDelta
bytes, throw a RangeError exception.
NOTE: No new Shared Data Block is
constructed and used here. The observable behaviour of growable
SharedArrayBuffers is specified by allocating a max-sized Shared Data Block at
construction time, and this step captures the requirement that
implementations that run out of memory must throw a
RangeError.
Let readByteLengthRawBytes be AtomicCompareExchangeInSharedBlock(byteLengthBlock,
0, 8, currentByteLengthRawBytes,
newByteLengthRawBytes).
If ByteListEqual(readByteLengthRawBytes,
currentByteLengthRawBytes) is true, return
undefined.
Set currentByteLengthRawBytes to
readByteLengthRawBytes.
Note
Spurious failures of the compare-exchange to update the length are prohibited. If the
bounds checking for the new length passes and the implementation is not out of
memory, a ReadModifyWriteSharedMemory
event (i.e. a successful compare-exchange) is always added into the candidate execution.
Parallel calls to SharedArrayBuffer.prototype.grow are totally ordered. For example,
consider two racing calls: sab.grow(10) and sab.grow(20).
One of the two calls is guaranteed to win the race. The call to
sab.grow(10) will never shrink sab even if
sab.grow(20) happened first; in that case it will instead throw a
RangeError.
25.2.5.4 get SharedArrayBuffer.prototype.growable
SharedArrayBuffer.prototype.growable is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
25.2.5.5 get SharedArrayBuffer.prototype.maxByteLength
SharedArrayBuffer.prototype.maxByteLength is an accessor
property whose set accessor function is undefined.
Its get accessor function performs the following steps when called:
The initial value of the %Symbol.toStringTag% property is the
String value "SharedArrayBuffer".
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: true }.
25.2.6 Properties of SharedArrayBuffer Instances
SharedArrayBuffer instances inherit properties from the SharedArrayBuffer
prototype object. SharedArrayBuffer instances each have an [[ArrayBufferData]] internal slot. SharedArrayBuffer instances which are
not growable each have an [[ArrayBufferByteLength]] internal slot.
SharedArrayBuffer instances which are growable each have an [[ArrayBufferByteLengthData]] internal slot and an [[ArrayBufferMaxByteLength]] internal slot.
Note
SharedArrayBuffer instances, unlike ArrayBuffer instances, are never detached.
We recommend that programs be tested in their deployment environments where possible. The
amount of available physical memory differ greatly between hardware devices. Similarly,
virtual memory subsystems also differ greatly between hardware devices as well as
operating systems. An application that runs without out-of-memory errors on a 64-bit
desktop web browser could run out of memory on a 32-bit mobile web browser.
When choosing a value for the "maxByteLength" option for growable
SharedArrayBuffer, we recommend that the smallest possible size
for the application be chosen. We recommend that "maxByteLength" does
not exceed 1073741824, or 1GiB.
Please note that successfully constructing a growable
SharedArrayBuffer for a particular maximum size does not
guarantee that future grows will succeed.
Not all loads of a growable
SharedArrayBuffer's length are synchronizing
seq-cst loads. Loads of the length that are for bounds-checking
of an integer-indexed property access, e.g.
u8[idx], are not synchronizing. In general, in the absence of explicit
synchronization, one property access being in-bound does not imply a subsequent property
access in the same agent is also in-bound. In contrast, explicit loads
of the length via the length and byteLength getters on
SharedArrayBuffer, %TypedArray%.prototype,
and DataView.prototype are synchronizing. Loads of the length that are performed by
built-in methods to check if a TypedArray is entirely out-of-bounds are also
synchronizing.
We recommend growable
SharedArrayBuffer be implemented as in-place growth via reserving
virtual memory up front.
Because grow operations can happen in parallel with memory accesses on a growable
SharedArrayBuffer, the constraints of the memory
model require that even unordered accesses do not "tear" (bits of
their values will not be mixed). In practice, this means the underlying data block of a
growable
SharedArrayBuffer cannot be grown by being copied without
stopping the world. We do not recommend stopping the world as an implementation strategy
because it introduces a serialization point and is slow.
Grown memory must appear zeroed from the moment of its creation, including to any racy
accesses in parallel. This can be accomplished via zero-filled-on-demand virtual memory
pages, or careful synchronization if manually zeroing memory.
Integer-indexed property access on
TypedArray views of growable
SharedArrayBuffers is intended to be optimizable similarly to access on TypedArray
views of non-growable SharedArrayBuffers, because integer-indexed property
loads on are not synchronizing on the underlying buffer's length (see programmer
guidelines above). For example, bounds checks for property accesses may still be hoisted
out of loops.
In practice it is difficult to implement growable
SharedArrayBuffer by copying on hosts that do not have virtual
memory, such as those running on embedded devices without an MMU. Memory usage behaviour
of growable SharedArrayBuffers on such hosts may significantly differ from that of
hosts with virtual
memory. Such hosts
should clearly communicate memory usage expectations to users.
25.3 DataView Objects
25.3.1 Abstract Operations For DataView Objects
25.3.1.1 DataView With Buffer Witness Records
A DataView With Buffer
Witness Record is a Record
value used to encapsulate a DataView along with a cached byte length of the viewed buffer.
It is used to help ensure there is a single shared memory read event of the byte length data
block when the viewed buffer is a growable SharedArrayBuffers.
DataView With Buffer Witness Records have the fields listed in Table 77.
The byte length of the object's [[ViewedArrayBuffer]] when the Record
was created.
25.3.1.2 MakeDataViewWithBufferWitnessRecord ( obj,
order )
The abstract operation MakeDataViewWithBufferWitnessRecord takes arguments obj (a
DataView) and order (seq-cst or
unordered) and returns a DataView With Buffer Witness
Record. It performs the following steps when called:
The abstract operation GetViewByteLength takes argument viewRecord (a DataView With Buffer Witness
Record) and returns a non-negative integer. It performs the following
steps when called:
The abstract operation IsViewOutOfBounds takes argument viewRecord (a DataView With Buffer Witness
Record) and returns a Boolean. It performs the following steps when
called:
Let view be viewRecord.[[Object]].
Let bufferByteLength be viewRecord.[[CachedBufferByteLength]].
Assert:
IsDetachedBuffer(view.[[ViewedArrayBuffer]]) is true if and
only if bufferByteLength is detached.
If bufferByteLength is detached, return
true.
Let byteOffsetStart be view.[[ByteOffset]].
If view.[[ByteLength]] is
auto, then
Let byteOffsetEnd be bufferByteLength.
Else,
Let byteOffsetEnd be byteOffsetStart +
view.[[ByteLength]].
If byteOffsetStart > bufferByteLength or
byteOffsetEnd > bufferByteLength, return
true.
NOTE: 0-length DataViews are not considered out-of-bounds.
Return false.
25.3.1.5 GetViewValue ( view,
requestIndex, isLittleEndian, type )
is the initial value of the "DataView" property of the global
object.
creates and initializes a new DataView when called as a constructor.
is not intended to be called as a function and will throw an exception when called in that
manner.
may be used as the value of an extends clause of a class definition. Subclass
constructors that intend to inherit the specified
DataView behaviour must include a super call to the DataView constructor to
create and initialize subclass instances with the internal state necessary to support the
DataView.prototype built-in methods.
does not have a [[DataView]], [[ViewedArrayBuffer]], [[ByteLength]], or
[[ByteOffset]] internal slot.
25.3.4.1 get DataView.prototype.buffer
DataView.prototype.buffer is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
Assert:
O has a [[ViewedArrayBuffer]] internal slot.
Let buffer be O.[[ViewedArrayBuffer]].
Return buffer.
25.3.4.2 get DataView.prototype.byteLength
DataView.prototype.byteLength is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
DataView.prototype.byteOffset is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
The initial value of the %Symbol.toStringTag% property is the
String value "DataView".
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: true }.
25.3.5 Properties of DataView Instances
DataView instances are ordinary objects that inherit properties from the
DataView prototype
object. DataView instances each have [[DataView]], [[ViewedArrayBuffer]], [[ByteLength]], and [[ByteOffset]] internal
slots.
Note
The value of the [[DataView]] internal slot is not used within
this specification. The simple presence of that internal slot is used within the
specification to identify objects created using the DataView constructor.
25.4 The Atomics Object
The Atomics object:
is %Atomics%.
is the initial value of the "Atomics" property of the global
object.
does not have a [[Construct]] internal method; it cannot be used as a
constructor
with the new operator.
does not have a [[Call]] internal method; it cannot be invoked as a
function.
The Atomics object provides functions that operate indivisibly (atomically) on shared memory array
cells as well as functions that let agents wait for and dispatch primitive events. When used with
discipline, the Atomics functions allow multi-agent programs that communicate through shared memory to
execute in a well-understood order even on parallel CPUs. The rules that govern shared-memory
communication are provided by the memory model, defined below.
Note
For informative guidelines for programming and implementing shared memory in ECMAScript,
please see the notes at the end of the memory model section.
25.4.1 Waiter Record
A Waiter Record is a Record value used to
denote a particular call to Atomics.wait or Atomics.waitAsync.
The agent
cluster has a store of WaiterList Records; the store is indexed by
(block, i), where block is a Shared Data Block and i
a byte offset into the memory of block. WaiterList Records are agent-independent: a lookup in
the store of WaiterList Records by (block, i) will result in the same
WaiterList Record in any agent in the agent cluster.
Each WaiterList Record has a critical
section that controls exclusive access to that WaiterList Record during evaluation.
Only a single agent may
enter a WaiterList Record's critical section at one time. Entering and leaving a WaiterList
Record's critical section is controlled by the abstract operationsEnterCriticalSection and LeaveCriticalSection. Operations on a
WaiterList Record—adding and removing waiting agents, traversing the list of agents, suspending and notifying agents on the list, setting
and retrieving the Synchronize event—may only be
performed by agents that
have entered the WaiterList Record's critical section.
The abstract operation RevalidateAtomicAccess takes arguments typedArray (a
TypedArray) and byteIndexInBuffer (an
integer) and
returns either a normal completion
containingunused or a throw completion.
This operation revalidates the index within the backing buffer for atomic operations after
all argument coercions are performed in Atomics methods, as argument coercions can have
arbitrary side effects, which could cause the buffer to become out of bounds. This operation
does not throw when typedArray's backing buffer is a SharedArrayBuffer. It
performs the following steps when called:
If byteIndexInBuffer ≥ taRecord.[[CachedBufferByteLength]], throw a
RangeError exception.
Return unused.
25.4.3.5 GetWaiterList ( block, i )
The abstract operation GetWaiterList takes arguments block (a Shared Data
Block) and i (a non-negative integer that is evenly divisible by 4)
and returns a WaiterList Record. It performs the
following steps when called:
Assert:
i and i + 3 are valid byte offsets within the memory of
block.
Return the WaiterList Record that is
referenced by the pair (block, i).
25.4.3.6 EnterCriticalSection ( WL )
The abstract operation EnterCriticalSection takes argument WL (a WaiterList Record) and returns
unused. It performs the following steps when called:
Append (WL.[[MostRecentLeaveEvent]],
enterEvent) to eventsRecord.[[AgentSynchronizesWith]].
Return unused.
EnterCriticalSection has contention when an agent attempting to enter the critical section must wait for another
agent to leave it.
When there is no contention, FIFO order of EnterCriticalSection calls is observable. When
there is contention, an implementation may choose an arbitrary order but may not cause an
agent to wait
indefinitely.
25.4.3.7 LeaveCriticalSection ( WL )
The abstract operation LeaveCriticalSection takes argument WL (a WaiterList Record) and returns
unused. It performs the following steps when called:
The abstract operation AddWaiter takes arguments WL (a WaiterList Record) and
waiterRecord (a Waiter Record) and returns
unused. It performs the following steps when called:
Assert:
There is no Waiter Record in WL.[[Waiters]] whose [[PromiseCapability]] field is waiterRecord.[[PromiseCapability]] and whose [[AgentSignifier]] field is waiterRecord.[[AgentSignifier]].
Append waiterRecord to WL.[[Waiters]].
Return unused.
25.4.3.9 RemoveWaiter ( WL, waiterRecord )
The abstract operation RemoveWaiter takes arguments WL (a WaiterList Record) and
waiterRecord (a Waiter Record) and returns
unused. It performs the following steps when called:
The abstract operation RemoveWaiters takes arguments WL (a WaiterList Record) and c (a
non-negative integer or +∞) and returns a List of Waiter
Records. It performs the following steps when called:
Let L be a List whose
elements are the first n elements of WL.[[Waiters]].
Remove the first n elements of WL.[[Waiters]].
Return L.
25.4.3.11 SuspendThisAgent ( WL,
waiterRecord )
The abstract operation SuspendThisAgent takes arguments WL (a WaiterList Record) and
waiterRecord (a Waiter Record) and returns
unused. It performs the following steps when called:
Perform LeaveCriticalSection(WL)
and suspend the surrounding agent until the time is
waiterRecord.[[TimeoutTime]], performing the
combined operation in such a way that a notification that arrives after the
critical section is exited but
before the suspension takes effect is not lost. The surrounding agent can only wake
from suspension due to a timeout or due to another agent calling NotifyWaiter with arguments
WL and thisAgent (i.e. via a call to
Atomics.notify).
The abstract operation NotifyWaiter takes arguments WL (a WaiterList Record) and
waiterRecord (a Waiter Record) and returns
unused. It performs the following steps when called:
The abstract operation EnqueueResolveInAgentJob takes arguments agentSignifier (an
agent
signifier), promiseCapability (a PromiseCapability Record), and
resolution ("ok" or "timed-out") and
returns unused. It performs the following steps when called:
Let resolveJob be a new JobAbstract Closure
with no parameters that captures agentSignifier,
promiseCapability, and resolution and performs the following
steps when called:
NOTE: There is no special handling of synchronous immediate timeouts.
Asynchronous immediate timeouts have special handling in order to fail fast
and avoid unnecessary Promise jobs.
Let timeoutTime be ℝ(now) + t +
additionalTimeout.
NOTE: When t is +∞, timeoutTime is also +∞.
Let waiterRecord be a new Waiter Record { [[AgentSignifier]]: thisAgent, [[PromiseCapability]]: promiseCapability, [[TimeoutTime]]: timeoutTime, [[Result]]: "ok" }.
additionalTimeout allows implementations to pad timeouts as necessary,
such as for reducing power consumption or coarsening timer resolution to mitigate
timing attacks. This value may differ from call to call of DoWait.
The abstract operation EnqueueAtomicsWaitAsyncTimeoutJob takes arguments WL (a
WaiterList Record) and
waiterRecord (a Waiter Record) and returns
unused. It performs the following steps when called:
Let timeoutJob be a new JobAbstract Closure
with no parameters that captures WL and waiterRecord and
performs the following steps when called:
The abstract operation AtomicCompareExchangeInSharedBlock takes arguments block (a
Shared Data
Block), byteIndexInBuffer (an integer), elementSize (a
non-negative integer), expectedBytes (a List of byte
values), and replacementBytes (a List of byte
values) and returns a List of byte
values. It performs the following steps when called:
Let rawBytesRead be a List of length
elementSize whose elements are nondeterministically chosen byte
values.
NOTE: In implementations, rawBytesRead is the result of a load-link, of a
load-exclusive, or of an operand of a read-modify-write instruction on the
underlying hardware. The nondeterminism is a semantic prescription of the memory
model to describe observable behaviour of hardware with weak
consistency.
NOTE: The comparison of the expected value and the read value is performed outside
of the read-modify-write modification
function to avoid needlessly strong synchronization when the
expected value is not equal to the read value.
If ByteListEqual(rawBytesRead,
expectedBytes) is true, then
Let second be a new read-modify-write
modification function with parameters
(oldBytes, newBytes) that captures nothing and
performs the following steps atomically when called:
Return newBytes.
Let event be ReadModifyWriteSharedMemory
{ [[Order]]: seq-cst, [[NoTear]]: true, [[Block]]: block, [[ByteIndex]]: byteIndexInBuffer, [[ElementSize]]: elementSize, [[Payload]]: replacementBytes, [[ModifyOp]]: second }.
Else,
Let event be ReadSharedMemory
{ [[Order]]: seq-cst, [[NoTear]]: true, [[Block]]: block, [[ByteIndex]]: byteIndexInBuffer, [[ElementSize]]: elementSize }.
Append event to eventsRecord.[[EventList]].
Append Chosen Value Record { [[Event]]: event, [[ChosenValue]]: rawBytesRead } to
execution.[[ChosenValues]].
Return rawBytesRead.
25.4.3.17 AtomicReadModifyWrite ( typedArray,
index, value, op )
The abstract operation ByteListBitwiseOp takes arguments op (&,
^, or |), xBytes (a List of byte
values), and yBytes (a List of byte
values) and returns a List of byte
values. The operation atomically performs a bitwise operation on all
byte
values of the arguments and returns a List of byte
values. It performs the following steps when called:
Assert:
xBytes and yBytes have the same number of elements.
Let resultByte be the result of applying the bitwise
inclusive OR operation to xByte and yByte.
Set i to i + 1.
Append resultByte to result.
Return result.
25.4.3.19 ByteListEqual ( xBytes, yBytes )
The abstract operation ByteListEqual takes arguments xBytes (a List of byte
values) and yBytes (a List of byte
values) and returns a Boolean. It performs the following steps when
called:
If xBytes and yBytes do not have the same number of elements,
return false.
Let i be 0.
For each element xByte of xBytes, do
Let yByte be yBytes[i].
If xByte ≠ yByte, return false.
Set i to i + 1.
Return true.
25.4.4 Atomics.add ( typedArray, index,
value )
This function performs the following steps when called:
Let add be a new read-modify-write modification
function with parameters (xBytes, yBytes)
that captures typedArray and performs the following steps atomically when
called:
This function performs the following steps when called:
Let and be a new read-modify-write modification
function with parameters (xBytes, yBytes)
that captures nothing and performs the following steps atomically when called:
25.4.7 Atomics.exchange ( typedArray, index,
value )
This function performs the following steps when called:
Let second be a new read-modify-write modification
function with parameters (oldBytes,
newBytes) that captures nothing and performs the following steps atomically
when called:
This function is an optimization primitive. The intuition is that if the atomic step of
an atomic primitive (compareExchange, load,
store, add, sub, and,
or, xor, or exchange) on a datum of size
n bytes will be performed without the surrounding agent
acquiring a lock outside the n bytes comprising the datum, then
Atomics.isLockFree(n) will return true.
High-performance algorithms will use this function to determine whether to use locks or
atomic operations in critical sections. If an atomic
primitive is not lock-free then it is often more efficient for an algorithm to provide
its own locking.
Atomics.isLockFree(4) always returns true as that can be
supported on all known relevant hardware. Being able to assume this will generally
simplify programs.
Regardless of the value returned by this function, all atomic operations are guaranteed
to be atomic. For example, they will never have a visible operation take place in the
middle of the operation (e.g., "tearing").
25.4.9 Atomics.load ( typedArray, index )
This function performs the following steps when called:
This function performs the following steps when called:
Let or be a new read-modify-write modification
function with parameters (xBytes, yBytes)
that captures nothing and performs the following steps atomically when called:
This function performs the following steps when called:
Let subtract be a new read-modify-write modification
function with parameters (xBytes, yBytes)
that captures typedArray and performs the following steps atomically when
called:
This function puts the surrounding agent in a wait queue and suspends
it until notified or until the wait times out, returning a String differentiating those cases.
This function performs the following steps when called:
Let xor be a new read-modify-write modification
function with parameters (xBytes, yBytes)
that captures nothing and performs the following steps atomically when called:
does not have a [[Construct]] internal method; it cannot be used as a
constructor
with the new operator.
does not have a [[Call]] internal method; it cannot be invoked as a
function.
The JSON Data Interchange Format is defined in ECMA-404. The JSON interchange format used in this
specification is exactly that described by ECMA-404. Conforming implementations of
JSON.parse and JSON.stringify must support the exact interchange format
described in the ECMA-404 specification without any deletions or extensions to the format.
25.5.1 JSON.parse ( text [ , reviver ] )
This function parses a JSON text (a JSON-formatted String) and produces an ECMAScript language value. The JSON
format represents literals, arrays, and objects with a syntax similar to the syntax for
ECMAScript literals, Array Initializers, and Object Initializers. After parsing, JSON objects
are realized as ECMAScript objects. JSON arrays are realized as ECMAScript Array instances. JSON
strings, numbers, booleans, and null are realized as ECMAScript Strings, Numbers, Booleans, and
null.
The optional reviver parameter is a function that takes two parameters, key
and value. It can filter and transform the results. It is called with each of the
key/value pairs produced by the parse, and its return value is used
instead of the original value. If it returns what it received, the structure is not modified. If
it returns undefined then the property is deleted from the result.
Assert: result is either a String,
a Number, a Boolean, an Object that is defined by either an ArrayLiteral or an
ObjectLiteral, or
null.
Return result.
It is not permitted for a conforming implementation of JSON.parse to extend the
JSON grammars. If an implementation wishes to support a modified or extended JSON
interchange format it must do so by defining a different parse function.
Note 1
Valid JSON text is a subset of the ECMAScript PrimaryExpression syntax. Step
1 verifies that
jsonString conforms to that subset, and step 8 asserts that evaluation
returns a value of an appropriate type.
However, because 13.2.5.5
behaves differently during ParseJSON, the same source text can produce different
results when evaluated as a PrimaryExpression rather than as
JSON. Furthermore, the Early Error for duplicate "__proto__"
properties in object literals, which likewise does not apply during ParseJSON, means
that not all texts accepted by ParseJSON are valid as a PrimaryExpression, despite
matching the grammar.
Note 2
In the case where there are duplicate name Strings within an object, lexically
preceding values for the same key shall be overwritten.
25.5.2 JSON.stringify ( value [ , replacer [ ,
space ] ] )
This function returns a String in UTF-16 encoded JSON format representing an ECMAScript language value, or
undefined. It can take three parameters. The value parameter is an
ECMAScript language value, which is
usually an object or array, although it can also be a String, Boolean, Number or
null. The optional replacer parameter is either a function that
alters the way objects and arrays are stringified, or an array of Strings and Numbers that acts
as an inclusion list for selecting the object properties that will be stringified. The optional
space parameter is a
String or Number that allows the result to have white space injected into
it to improve human readability.
Let state be the JSON Serialization
Record { [[ReplacerFunction]]:
ReplacerFunction, [[Stack]]: stack, [[Indent]]: indent, [[Gap]]:
gap, [[PropertyList]]:
PropertyList }.
JSON structures are allowed to be nested to any depth, but they must be acyclic. If
value is or contains a cyclic structure, then this function must throw a
TypeError exception. This is an example of a value that cannot be
stringified:
a = [];
a[0] = a;
my_text = JSON.stringify(a); // This must throw a TypeError.
Note 2
Symbolic primitive values are rendered as follows:
The null value is rendered in JSON text as the String value
"null".
The undefined value is not rendered.
The true value is rendered in JSON text as the String value
"true".
The false value is rendered in JSON text as the String value
"false".
Note 3
String values are wrapped in QUOTATION MARK (") code units. The code units
" and \ are escaped with \ prefixes. Control
characters code units are replaced with escape sequences \uHHHH, or with
the shorter forms, \b (BACKSPACE), \f (FORM FEED),
\n (LINE FEED), \r (CARRIAGE RETURN), \t
(CHARACTER TABULATION).
Note 4
Finite numbers
are stringified as if by calling ToString(number).
NaN and Infinity regardless of sign are
represented as the String value "null".
Note 5
Values that do not have a JSON representation (such as undefined and
functions) do not produce a String. Instead they produce the
undefined value. In arrays these values are represented as the String
value "null". In objects an unrepresentable value causes the property
to be excluded from stringification.
Note 6
An object is rendered as U+007B (LEFT CURLY BRACKET) followed by zero or more properties,
separated with a U+002C (COMMA), closed with a U+007D (RIGHT CURLY BRACKET). A property
is a quoted String representing the property name, a U+003A (COLON), and then
the stringified property value. An array is rendered as an opening U+005B (LEFT SQUARE
BRACKET) followed by zero or more values, separated with a U+002C (COMMA), closed with a
U+005D (RIGHT SQUARE BRACKET).
25.5.2.1 JSON Serialization Record
A JSON Serialization Record is
a Record value used to
enable serialization to the JSON format.
JSON Serialization Records have the fields listed in Table 80.
The abstract operation SerializeJSONProperty takes arguments state (a JSON Serialization Record),
key (a String), and holder (an Object) and returns either a normal completion
containing either a String or undefined, or a
throw completion. It
performs the following steps when called:
The abstract operation QuoteJSONString takes argument value (a String) and returns
a String. It wraps value in 0x0022 (QUOTATION MARK) code units and escapes
certain other code units within it. This operation interprets value as a sequence
of UTF-16 encoded code points, as described in 6.1.4. It performs
the following steps when called:
Let product be the String value consisting solely of the code unit 0x0022
(QUOTATION MARK).
If C is listed in the “Code Point” column of Table 81,
then
Set product to the string-concatenation
of product and the escape sequence for C as
specified in the “Escape Sequence” column of the corresponding row.
Set product to the string-concatenation of
product and the code unit 0x0022 (QUOTATION MARK).
Return product.
Table 81: JSON Single Character Escape Sequences
Code Point
Unicode Character Name
Escape Sequence
U+0008
BACKSPACE
\b
U+0009
CHARACTER TABULATION
\t
U+000A
LINE FEED (LF)
\n
U+000C
FORM FEED (FF)
\f
U+000D
CARRIAGE RETURN (CR)
\r
U+0022
QUOTATION MARK
\"
U+005C
REVERSE SOLIDUS
\\
25.5.2.4 UnicodeEscape ( C )
The abstract operation UnicodeEscape takes argument C (a code unit) and returns a
String. It represents C as a Unicode escape sequence. It performs the following
steps when called:
Let properties be the String value formed by
concatenating all the element Strings of partial with
each adjacent pair of Strings separated with the code unit 0x002C
(COMMA). A comma is not inserted either before the first String or
after the last String.
Let separator be the string-concatenation
of the code unit 0x002C (COMMA), the code unit 0x000A (LINE FEED),
and state.[[Indent]].
Let properties be the String value formed by
concatenating all the element Strings of partial with
each adjacent pair of Strings separated with separator.
The separator String is not inserted either before the
first String or after the last String.
Let final be the string-concatenation
of "{", the code unit 0x000A (LINE FEED),
state.[[Indent]],
properties, the code unit 0x000A (LINE FEED),
stepBack, and "}".
Let properties be the String value formed by
concatenating all the element Strings of partial with
each adjacent pair of Strings separated with the code unit 0x002C
(COMMA). A comma is not inserted either before the first String or
after the last String.
Let separator be the string-concatenation
of the code unit 0x002C (COMMA), the code unit 0x000A (LINE FEED),
and state.[[Indent]].
Let properties be the String value formed by
concatenating all the element Strings of partial with
each adjacent pair of Strings separated with separator.
The separator String is not inserted either before the
first String or after the last String.
Let final be the string-concatenation
of "[", the code unit 0x000A (LINE FEED),
state.[[Indent]],
properties, the code unit 0x000A (LINE FEED),
stepBack, and "]".
Remove the last element of state.[[Stack]].
Set state.[[Indent]] to stepBack.
Return final.
Note
The representation of arrays includes only the elements in the interval
from +0𝔽 (inclusive) to array.length
(exclusive). Properties whose keys are not array indices are excluded
from the stringification. An array is stringified as an opening LEFT SQUARE BRACKET,
elements separated by COMMA, and a closing RIGHT SQUARE BRACKET.
25.5.3 JSON [ %Symbol.toStringTag% ]
The initial value of the %Symbol.toStringTag% property is the
String value "JSON".
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: true }.
26 Managing Memory
26.1 WeakRef Objects
A WeakRef is an object that is used to refer
to a target object or symbol without preserving it from garbage collection. WeakRefs can be dereferenced to allow access
to the target value, if the target hasn't been reclaimed by garbage collection.
is the initial value of the "WeakRef" property of the global
object.
creates and initializes a new WeakRef when called as a constructor.
is not intended to be called as a function and will throw an exception when called in that
manner.
may be used as the value in an extends clause of a class definition. Subclass
constructors that intend to inherit the specified
WeakRef behaviour must include a super call to the
WeakRefconstructor to create and initialize the subclass
instance with the internal state necessary to support the WeakRef.prototype
built-in methods.
26.1.1.1 WeakRef ( target )
This function performs the following steps when called:
If NewTarget is undefined, throw a TypeError
exception.
If CanBeHeldWeakly(target)
is false, throw a TypeError exception.
If the WeakRef returns a
target value that is not undefined, then this
target value should not be garbage collected until the current execution
of ECMAScript code has completed. The AddToKeptObjects
operation makes sure read consistency is maintained.
let target = { foo() {} };
let weakRef = newWeakRef(target);
// ... later ...if (weakRef.deref()) {
weakRef.deref().foo();
}
In the above example, if the first deref does not evaluate to
undefined then the second deref cannot either.
The initial value of the %Symbol.toStringTag% property is the
String value "WeakRef".
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: true }.
26.1.4 WeakRef Abstract Operations
26.1.4.1 WeakRefDeref ( weakRef )
The abstract operation WeakRefDeref takes argument weakRef (a WeakRef) and returns an ECMAScript language value. It
performs the following steps when called:
A FinalizationRegistry is an
object that manages registration and unregistration of cleanup operations that are performed when
target objects and symbols are garbage collected.
is the initial value of the "FinalizationRegistry" property of the
global
object.
creates and initializes a new FinalizationRegistry when called as a constructor.
is not intended to be called as a function and will throw an exception when called in that
manner.
may be used as the value in an extends clause of a class definition. Subclass
constructors that intend to inherit the specified
FinalizationRegistry behaviour must include a super call to the
FinalizationRegistryconstructor to create and initialize the subclass
instance with the internal state necessary to support the
FinalizationRegistry.prototype built-in methods.
26.2.1.1 FinalizationRegistry ( cleanupCallback )
This function performs the following steps when called:
If NewTarget is undefined, throw a TypeError
exception.
If IsCallable(cleanupCallback)
is false, throw a TypeError exception.
Let finalizationRegistry be ? OrdinaryCreateFromConstructor(NewTarget,
"%FinalizationRegistry.prototype%", « [[Realm]], [[CleanupCallback]],
[[Cells]] »).
If unregisterToken is not undefined, throw a
TypeError exception.
Set unregisterToken to empty.
Let cell be the Record { [[WeakRefTarget]]: target, [[HeldValue]]: heldValue, [[UnregisterToken]]: unregisterToken }.
Append cell to finalizationRegistry.[[Cells]].
Return undefined.
Note
Based on the algorithms and definitions in this specification, cell.[[HeldValue]] is live when
finalizationRegistry.[[Cells]] contains
cell; however, this does not necessarily mean that cell.[[UnregisterToken]] or cell.[[Target]] are live. For example,
registering an object with itself as its unregister token would not keep the object
alive forever.
An interface is a set of property keys whose associated values match a
specific specification. Any object that provides all the properties as described by an
interface's specification conforms to that interface. An interface is not represented
by a distinct object. There may be many separately implemented objects that conform to any
interface. An individual object may conform to multiple interfaces.
27.1.1.1 The Iterable Interface
The iterable interface includes the property described in Table 82:
The returned object must conform to the IteratorResult
interface. If a previous call to the
next method of an iterator has
returned an IteratorResult
object whose "done" property
is true, then all subsequent calls to the
next method of that object should also return an IteratorResult
object whose "done" property
is true. However, this requirement is not enforced.
Note 1
Arguments may be passed to the next function but their interpretation
and validity is dependent upon the target iterator. The for-of statement and other
common users of iterators do not pass any arguments, so iterator objects that expect
to be used in such a manner must be prepared to deal with being called with no
arguments.
The returned object must conform to the IteratorResult
interface. Invoking this method notifies the
iterator object
that the caller does not intend to make any more next
method calls to the iterator. The
returned IteratorResult
object will typically have a
"done" property whose value is
true, and a "value" property with
the value passed as the argument of the return method.
However, this requirement is not enforced.
The returned object must conform to the IteratorResult
interface. Invoking this method notifies the
iterator object
that the caller has detected an error condition. The argument may be
used to identify the error condition and typically will be an exception
object. A typical response is to throw the value passed as
the argument. If the method does not throw, the returned
IteratorResult
object will typically have a
"done" property whose value is
true.
Note 2
Typically callers of these methods should check for their existence before invoking
them. Certain ECMAScript language features including
for-of, yield*, and array destructuring call
these methods after performing an existence check. Most ECMAScript library functions
that accept iterable objects as arguments
also conditionally call them.
27.1.1.3 The Async Iterable Interface
The async iterable interface includes the properties described in
Table
85:
An object that implements the async iterator interface must include the properties in Table 86. Such objects may also
implement the properties in Table 87.
The returned promise, when fulfilled, must fulfill with an object
that conforms to the IteratorResult
interface. If a previous call to the
next method of an async
iterator has returned a promise for an
IteratorResult
object whose "done"
property is true, then all subsequent calls to
the next method of that object should also return a
promise for an IteratorResult
object whose "done"
property is true. However, this requirement is
not enforced.
Additionally, the IteratorResult
object that serves as a fulfillment value
should have a "value" property whose value is not
a promise (or "thenable"). However, this requirement is also not
enforced.
Note 1
Arguments may be passed to the next function but their interpretation
and validity is dependent upon the target async iterator. The
for-await-of statement and other common users
of async iterators do not pass any arguments, so async iterator objects that expect
to be used in such a manner must be prepared to deal with being called with no
arguments.
The returned promise, when fulfilled, must fulfill with an object
that conforms to the IteratorResult
interface. Invoking this method notifies the
async iterator
object that the caller does not intend to
make any more next method calls to the async
iterator. The returned promise will fulfill
with an IteratorResult
object which will typically have a
"done" property whose value is
true, and a "value" property
with the value passed as the argument of the return
method. However, this requirement is not enforced.
Additionally, the IteratorResult
object that serves as a fulfillment value
should have a "value" property whose value is not
a promise (or "thenable"). If the argument value is used in the
typical manner, then if it is a rejected promise, a promise rejected
with the same reason should be returned; if it is a fulfilled
promise, then its fulfillment value should be used as the
"value" property of the returned promise's
IteratorResult
object fulfillment value. However, these
requirements are also not enforced.
The returned promise, when fulfilled, must fulfill with an object
that conforms to the IteratorResult
interface. Invoking this method notifies the
async iterator
object that the caller has detected an error
condition. The argument may be used to identify the error condition
and typically will be an exception object. A typical response is to
return a rejected promise which rejects with the value passed as the
argument.
If the returned promise is fulfilled, the IteratorResult
object fulfillment value will typically have
a "done" property whose value is
true. Additionally, it should have a
"value" property whose value is not a promise (or
"thenable"), but this requirement is not enforced.
Note 2
Typically callers of these methods should check for their existence before invoking
them. Certain ECMAScript language features including
for-await-of and yield* call
these methods after performing an existence check.
27.1.1.5 The IteratorResult Interface
The IteratorResult
interface includes the properties listed in Table 88:
Table 88: IteratorResult Interface Properties
Property
Value
Requirements
"done"
a Boolean
This is the result status of an iteratornext method call. If the end of the iterator was
reached "done" is true. If the end
was not reached "done" is false
and a value is available. If a "done" property
(either own or inherited) does not exist, it is considered to have the
value false.
If done is false, this is the current iteration
element value. If done is true, this is the return
value of the iterator, if it
supplied one. If the iterator does not
have a return value, "value" is
undefined. In that case, the
"value" property may be absent from the conforming
object if it does not inherit an explicit "value"
property.
27.1.2 Iterator Helper Objects
An Iterator Helper object is an
ordinary
object that represents a lazy transformation of some specific source
iterator object. There is not a named
constructor
for Iterator Helper objects. Instead, Iterator Helper objects are created by calling certain
methods of Iterator instance objects.
NOTE: Once a generator enters the completed state it never leaves it and
its associated execution
context is never resumed. Any execution state
associated with O can be discarded at this point.
All objects defined in this specification that implement the iterator interface also inherit
from %Iterator.prototype%. ECMAScript code may also define objects that inherit from
%Iterator.prototype%. %Iterator.prototype% provides a place where additional methods
that are applicable to all iterator objects may be added.
The following expression is one way that ECMAScript code can access the
%Iterator.prototype% object:
Iterator.prototype.constructor is an accessor property with
attributes { [[Enumerable]]: false, [[Configurable]]: true }. The [[Get]] and [[Set]] attributes are defined
as follows:
27.1.4.1.1 get Iterator.prototype.constructor
The value of the [[Get]] attribute is a built-in function that
requires no arguments. It performs the following steps when called:
Iterator.prototype[%Symbol.toStringTag%] is an accessor property with
attributes { [[Enumerable]]: false, [[Configurable]]: true }. The [[Get]] and [[Set]] attributes are defined
as follows:
27.1.4.14.1 get Iterator.prototype [ %Symbol.toStringTag% ]
The value of the [[Get]] attribute is a built-in function that
requires no arguments. It performs the following steps when called:
Return "Iterator".
27.1.4.14.2 set Iterator.prototype [ %Symbol.toStringTag% ]
The value of the [[Set]] attribute is a built-in function that
takes an argument v. It performs the following steps when called:
All objects defined in this specification that implement the async iterator interface also
inherit from %AsyncIteratorPrototype%. ECMAScript code may also define objects that
inherit from %AsyncIteratorPrototype%. The %AsyncIteratorPrototype% object provides a
place where additional methods that are applicable to all async iterator objects may be
added.
This function performs the following steps when called:
Return the this value.
The value of the "name" property of this function is
"[Symbol.asyncIterator]".
27.1.6 Async-from-Sync Iterator Objects
An Async-from-Sync Iterator
object is an async iterator that adapts a specific
synchronous iterator. Async-from-Sync Iterator objects
are never directly accessible to ECMAScript code. There is not a named constructor for
Async-from-Sync Iterator objects. Instead, Async-from-Sync Iterator objects are created by the
CreateAsyncFromSyncIterator
abstract operation as needed.
The abstract operation CreateAsyncFromSyncIterator takes argument
syncIteratorRecord (an Iterator Record) and returns an
Iterator Record. It is used to create an
async Iterator Record from a synchronous
Iterator Record. It performs the
following steps when called:
The abstract operation AsyncFromSyncIteratorContinuation takes arguments result
(an Object), promiseCapability (a PromiseCapability
Record for an intrinsic %Promise%),
syncIteratorRecord (an Iterator Record), and
closeOnRejection (a Boolean) and returns a Promise. It performs the following
steps when called:
NOTE: Because promiseCapability is derived from the intrinsic %Promise%, the calls to
promiseCapability.[[Reject]] entailed by the use
IfAbruptRejectPromise below
are guaranteed not to throw.
NOTE: onFulfilled is used when processing the "value"
property of an IteratorResult object in
order to wait for its value if it is a promise and re-package the result in a new
"unwrapped" IteratorResult object.
If done is true, or if closeOnRejection is
false, then
Let onRejected be undefined.
Else,
Let closeIterator be a new Abstract
Closure with parameters (error) that
captures syncIteratorRecord and performs the following steps when
called:
A Promise is an object that is used as a placeholder for the eventual results of a deferred (and
possibly asynchronous) computation.
Any Promise is in one of three mutually exclusive states: fulfilled, rejected, and
pending:
A promise p is fulfilled if p.then(f, r) will immediately enqueue a
Job to call the function
f.
A promise p is rejected if p.then(f, r) will immediately enqueue a
Job to call the function
r.
A promise is pending if it is neither fulfilled nor rejected.
A promise is said to be settled if it is not pending, i.e. if it is either fulfilled or
rejected.
A promise is resolved if it is settled or if it has been “locked in” to match the state of
another promise. Attempting to resolve or reject a resolved promise has no effect. A promise is
unresolved if it is not resolved. An unresolved promise is always in the pending state. A
resolved promise may be pending, fulfilled or rejected.
27.2.1 Promise Abstract Operations
27.2.1.1 PromiseCapability Records
A PromiseCapability Record is a
Record value used to
encapsulate a Promise or promise-like object along with the functions that are capable of
resolving or rejecting that promise. PromiseCapability Records are produced by the NewPromiseCapability abstract
operation.
PromiseCapability Records have the fields listed in Table 90.
A PromiseReaction Record is a
Record value used to
store information about how a promise should react when it becomes resolved or rejected with
a given value. PromiseReaction Records are created by the PerformPromiseThen abstract operation,
and are used by the Abstract Closure returned by NewPromiseReactionJob.
PromiseReaction Records have the fields listed in Table 91.
The function that should be applied to the incoming value, and whose
return value will govern what happens to the derived promise. If [[Handler]] is empty, a
function that depends on the value of [[Type]]
will be used instead.
27.2.1.3 CreateResolvingFunctions ( promise )
The abstract operation CreateResolvingFunctions takes argument promise (a Promise)
and returns a Record with fields
[[Resolve]] (a function object) and [[Reject]] (a function object). It performs the following
steps when called:
Let alreadyResolved be the Record { [[Value]]: false }.
The "length" property of a promise resolve function is
1𝔽.
27.2.1.4 FulfillPromise ( promise, value )
The abstract operation FulfillPromise takes arguments promise (a Promise) and
value (an ECMAScript language value) and
returns unused. It performs the following steps when called:
If IsConstructor(C) is
false, throw a TypeError exception.
NOTE: C is assumed to be a constructor function that
supports the parameter conventions of the Promise constructor (see 27.2.3.1).
Let resolvingFunctions be the Record { [[Resolve]]: undefined, [[Reject]]: undefined }.
Let executorClosure be a new Abstract Closure
with parameters (resolve, reject) that captures
resolvingFunctions and performs the following steps when called:
If resolvingFunctions.[[Resolve]] is not
undefined, throw a TypeError
exception.
If resolvingFunctions.[[Reject]] is not
undefined, throw a TypeError
exception.
If IsCallable(resolvingFunctions.[[Resolve]]) is false, throw a
TypeError exception.
If IsCallable(resolvingFunctions.[[Reject]]) is false, throw a
TypeError exception.
Return the PromiseCapability
Record { [[Promise]]:
promise, [[Resolve]]:
resolvingFunctions.[[Resolve]], [[Reject]]: resolvingFunctions.[[Reject]] }.
Note
This abstract operation supports Promise subclassing, as it is generic on any
constructor that calls a passed executor
function argument in the same way as the Promise constructor. It is used to
generalize static methods of the Promise constructor to any
subclass.
27.2.1.6 IsPromise ( x )
The abstract operation IsPromise takes argument x (an ECMAScript language value) and
returns a Boolean. It checks for the promise brand on an object. It performs the following
steps when called:
If x does not have a [[PromiseState]] internal
slot, return false.
Return true.
27.2.1.7 RejectPromise ( promise, reason )
The abstract operation RejectPromise takes arguments promise (a Promise) and
reason (an ECMAScript language value) and
returns unused. It performs the following steps when called:
The abstract operation TriggerPromiseReactions takes arguments reactions (a
List of PromiseReaction Records) and
argument (an ECMAScript language value) and
returns unused. It enqueues a new Job for each record in
reactions. Each such Job processes the [[Type]] and
[[Handler]] of the PromiseReaction
Record, and if the [[Handler]] is not
empty, calls it passing the given argument. If the [[Handler]] is empty, the behaviour is
determined by the [[Type]]. It performs the following steps when
called:
The host-defined abstract operation
HostPromiseRejectionTracker takes arguments promise (a Promise) and
operation ("reject" or "handle") and
returns unused. It allows host environments to track
promise rejections.
The default implementation of HostPromiseRejectionTracker is to return
unused.
Note 1
HostPromiseRejectionTracker is called in two scenarios:
When a promise is rejected without any handlers, it is called with its
operation argument set to "reject".
When a handler is added to a rejected promise for the first time, it is called
with its operation argument set to "handle".
A typical implementation of HostPromiseRejectionTracker might try to notify
developers of unhandled rejections, while also being careful to notify them if such
previous notifications are later invalidated by new handlers being attached.
Note 2
If operation is "handle", an implementation should not
hold a reference to promise in a way that would interfere with garbage
collection. An implementation may hold a reference to promise if
operation is "reject", since it is expected that
rejections will be rare and not on hot code paths.
The abstract operation NewPromiseReactionJob takes arguments reaction (a PromiseReaction Record) and
argument (an ECMAScript language value) and
returns a Record with fields
[[Job]] (a JobAbstract Closure) and
[[Realm]] (a Realm Record or null). It
returns a new JobAbstract Closure that applies the
appropriate handler to the incoming value, and uses the handler's return value to resolve or
reject the derived promise associated with that handler. It performs the following steps
when called:
Let job be a new JobAbstract Closure
with no parameters that captures reaction and argument and
performs the following steps when called:
NOTE: handlerRealm is never null unless the
handler is undefined. When the handler is a revoked Proxy
and no ECMAScript code runs, handlerRealm is used to create error
objects.
Return the Record { [[Job]]: job, [[Realm]]:
handlerRealm }.
27.2.2.2 NewPromiseResolveThenableJob (
promiseToResolve, thenable, then )
The abstract operation NewPromiseResolveThenableJob takes arguments
promiseToResolve (a Promise), thenable (an Object), and
then (a JobCallback Record) and returns a
Record with fields
[[Job]] (a JobAbstract Closure) and
[[Realm]] (a Realm Record). It performs the following steps
when called:
Let job be a new JobAbstract Closure
with no parameters that captures promiseToResolve, thenable,
and then and performs the following steps when called:
NOTE: thenRealm is never null. When
then.[[Callback]] is a revoked Proxy and no code
runs, thenRealm is used to create error objects.
Return the Record { [[Job]]: job, [[Realm]]:
thenRealm }.
Note
This Job uses the
supplied thenable and its then method to resolve the given promise.
This process must take place as a Job to ensure that the evaluation of the
then method occurs after evaluation of any surrounding code has
completed.
is the initial value of the "Promise" property of the global
object.
creates and initializes a new Promise when called as a constructor.
is not intended to be called as a function and will throw an exception when called in that
manner.
may be used as the value in an extends clause of a class definition. Subclass
constructors that intend to inherit the specified
Promise behaviour must include a super call to the Promise constructor to
create and initialize the subclass instance with the internal state necessary to support the
Promise and Promise.prototype built-in methods.
27.2.3.1 Promise ( executor )
This function performs the following steps when called:
If NewTarget is undefined, throw a TypeError
exception.
If IsCallable(executor) is
false, throw a TypeError exception.
Let promise be ? OrdinaryCreateFromConstructor(NewTarget,
"%Promise.prototype%", « [[PromiseState]], [[PromiseResult]], [[PromiseFulfillReactions]], [[PromiseRejectReactions]], [[PromiseIsHandled]] »).
Set promise.[[PromiseState]] to
pending.
Set promise.[[PromiseResult]] to
empty.
Set promise.[[PromiseFulfillReactions]] to a new
empty List.
Set promise.[[PromiseRejectReactions]] to a new
empty List.
The executor argument must be a function object. It is
called for initiating and reporting completion of the possibly deferred action
represented by this Promise. The executor is called with two arguments:
resolve and reject. These are functions that may be used by
the executor function to report eventual completion or failure of the
deferred computation. Returning from the executor function does not mean that the
deferred action has been completed but only that the request to eventually perform
the deferred action has been accepted.
The resolve function that is passed to an executor function
accepts a single argument. The executor code may eventually call the
resolve function to indicate that it wishes to resolve the associated
Promise. The argument passed to the resolve function represents the
eventual value of the deferred action and can be either the actual fulfillment value
or another promise which will provide the value if it is fulfilled.
The reject function that is passed to an executor function
accepts a single argument. The executor code may eventually call the
reject function to indicate that the associated Promise is rejected and
will never be fulfilled. The argument passed to the reject function is
used as the rejection value of the promise. Typically it will be an Error object.
The resolve and reject functions passed to an executor function by the
Promise constructor have the capability to
actually resolve and reject the associated promise. Subclasses may have different
constructor behaviour that passes in
customized values for resolve and reject.
This function returns a new promise which is fulfilled with an array of fulfillment values
for the passed promises, or rejects with the reason of the first passed promise that
rejects. It resolves all elements of the passed iterable to promises as
it runs this algorithm.
A Promise.all resolve element function is an anonymous built-in function
that is used to resolve a specific Promise.all element. Each
Promise.all resolve element function has [[Index]], [[Values]], [[Capability]], [[RemainingElements]],
and [[AlreadyCalled]] internal slots.
When a Promise.all resolve element function is called with argument
x, the following steps are taken:
The "length" property of a Promise.all resolve element
function is 1𝔽.
27.2.4.2 Promise.allSettled ( iterable )
This function returns a promise that is fulfilled with an array of promise state snapshots,
but only after all the original promises have settled, i.e. become either fulfilled or
rejected. It resolves all elements of the passed iterable to promises as
it runs this algorithm.
27.2.4.2.2Promise.allSettled Resolve Element
Functions
A Promise.allSettled resolve element function is an anonymous built-in
function that is used to resolve a specific Promise.allSettled element.
Each Promise.allSettled resolve element function has [[Index]], [[Values]], [[Capability]], [[RemainingElements]],
and [[AlreadyCalled]] internal slots.
When a Promise.allSettled resolve element function is called with argument
x, the following steps are taken:
The "length" property of a Promise.allSettled resolve
element function is 1𝔽.
27.2.4.2.3Promise.allSettled Reject Element
Functions
A Promise.allSettled reject element function is an anonymous built-in
function that is used to reject a specific Promise.allSettled element. Each
Promise.allSettled reject element function has [[Index]], [[Values]], [[Capability]], [[RemainingElements]],
and [[AlreadyCalled]] internal slots.
When a Promise.allSettled reject element function is called with argument
x, the following steps are taken:
The "length" property of a Promise.allSettled reject
element function is 1𝔽.
27.2.4.3 Promise.any ( iterable )
This function returns a promise that is fulfilled by the first given promise to be fulfilled,
or rejected with an AggregateError holding the rejection reasons if all of the
given promises are rejected. It resolves all elements of the passed iterable to promises as it runs this
algorithm.
A Promise.any reject element function is an anonymous built-in function that
is used to reject a specific Promise.any element. Each
Promise.any reject element function has [[Index]],
[[Errors]], [[Capability]], [[RemainingElements]], and [[AlreadyCalled]] internal slots.
When a Promise.any reject element function is called with argument
x, the following steps are taken:
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
27.2.4.5 Promise.race ( iterable )
This function returns a new promise which is settled in the same way as the first passed
promise to settle. It resolves all elements of the passed iterable to promises as
it runs this algorithm.
If the iterable argument yields no values or if none of the promises
yielded by iterable ever settle, then the pending promise returned by
this method will never be settled.
Note 2
This function expects its this value to be a constructor function that supports the
parameter conventions of the Promise constructor. It also
expects that its this value provides a resolve
method.
Perform ? Call(promiseCapability.[[Reject]], undefined, «
r »).
Return promiseCapability.[[Promise]].
Note
This function expects its this value to be a constructor function that supports the
parameter conventions of the Promise constructor.
27.2.4.7 Promise.resolve ( x )
This function returns either a new promise resolved with the passed argument, or the argument
itself if the argument is a promise produced by this constructor.
Promise[%Symbol.species%] is an accessor property whose set
accessor function is undefined. Its get accessor function performs the
following steps when called:
Return the this value.
The value of the "name" property of this function is "get
[Symbol.species]".
Note
Promise prototype methods normally use their this value's
constructor to create a derived object.
However, a subclass constructor may over-ride that default
behaviour by redefining its %Symbol.species% property.
The abstract operation PerformPromiseThen takes arguments promise (a Promise),
onFulfilled (an ECMAScript language
value), and onRejected (an ECMAScript language value)
and optional argument resultCapability (a PromiseCapability Record)
and returns an ECMAScript language value.
It performs the “then” operation on promise using onFulfilled and
onRejected as its settlement actions. If resultCapability is
passed, the result is stored by updating resultCapability's promise. If it is
not passed, then PerformPromiseThen is being called by a specification-internal
operation where the result does not matter. It performs the following steps when called:
creates and initializes a new GeneratorFunction when called as a function rather than as a
constructor. Thus the function call
GeneratorFunction (…) is equivalent to the object creation expression
new GeneratorFunction (…) with the same arguments.
may be used as the value of an extends clause of a class definition. Subclass
constructors that intend to inherit the specified
GeneratorFunction behaviour must include a super call to the GeneratorFunction
constructor to create and initialize subclass
instances with the internal slots necessary for built-in GeneratorFunction behaviour. All
ECMAScript syntactic forms for defining generator function objects create direct
instances of GeneratorFunction. There is no syntactic means to create instances of
GeneratorFunction subclasses.
The initial value of the %Symbol.toStringTag% property is the
String value "GeneratorFunction".
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: true }.
27.3.4 GeneratorFunction Instances
Every GeneratorFunction instance is an ECMAScript function object and has the
internal slots listed in Table
30. The value of the [[IsClassConstructor]]
internal slot for all such instances is false.
Each GeneratorFunction instance has the following own properties:
27.3.4.1 length
The specification for the "length" property of Function instances given in
20.2.4.1 also applies to
GeneratorFunction instances.
27.3.4.2 name
The specification for the "name" property of Function instances given in
20.2.4.2 also applies to
GeneratorFunction instances.
27.3.4.3 prototype
Whenever a GeneratorFunction instance is created another ordinary object is also
created and is the initial value of the generator function's "prototype"
property. The value of the prototype property is used to initialize the [[Prototype]] internal slot of a newly created Generator when the
generator function object is invoked using [[Call]].
This property has the attributes { [[Writable]]:
true, [[Enumerable]]: false,
[[Configurable]]: false }.
Note
Unlike Function instances, the object that is the value of a GeneratorFunction's
"prototype" property does not have a
"constructor" property whose value is the GeneratorFunction
instance.
creates and initializes a new AsyncGeneratorFunction when called as a function rather than
as a constructor. Thus the function call
AsyncGeneratorFunction (...) is equivalent to the object creation expression
new AsyncGeneratorFunction (...) with the same arguments.
may be used as the value of an extends clause of a class definition. Subclass
constructors that intend to inherit the specified
AsyncGeneratorFunction behaviour must include a super call to the
AsyncGeneratorFunction constructor to create and initialize subclass
instances with the internal slots necessary for built-in AsyncGeneratorFunction behaviour.
All ECMAScript syntactic forms for defining async generator function
objects create direct instances of AsyncGeneratorFunction. There is
no syntactic means to create instances of AsyncGeneratorFunction subclasses.
The initial value of the %Symbol.toStringTag% property is the
String value "AsyncGeneratorFunction".
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: true }.
27.4.4 AsyncGeneratorFunction Instances
Every AsyncGeneratorFunction instance is an ECMAScript function object and has the
internal slots listed in Table
30. The value of the [[IsClassConstructor]]
internal slot for all such instances is false.
Each AsyncGeneratorFunction instance has the following own properties:
27.4.4.1 length
The value of the "length" property is an integral Number that indicates
the typical number of arguments expected by the AsyncGeneratorFunction. However, the
language permits the function to be invoked with some other number of arguments. The
behaviour of an AsyncGeneratorFunction when invoked on a number of arguments other than the
number specified by its "length" property depends on the function.
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: true }.
27.4.4.2 name
The specification for the "name" property of Function instances given in
20.2.4.2 also applies to
AsyncGeneratorFunction instances.
27.4.4.3 prototype
Whenever an AsyncGeneratorFunction instance is created, another ordinary
object is also created and is the initial value of the async
generator function's "prototype" property. The value of the prototype
property is used to initialize the [[Prototype]] internal slot of a
newly created AsyncGenerator when the generator function object is invoked
using [[Call]].
This property has the attributes { [[Writable]]:
true, [[Enumerable]]: false,
[[Configurable]]: false }.
Note
Unlike function instances, the object that is the value of an
AsyncGeneratorFunction's "prototype" property does not have a
"constructor" property whose value is the AsyncGeneratorFunction
instance.
Generator instances directly inherit properties from the initial value of the
"prototype" property of the generator function that created the instance.
Generator instances indirectly inherit properties from %GeneratorPrototype%.
The abstract operation GeneratorStart takes arguments generator (a Generator) and
generatorBody (a FunctionBodyParse
Node or an Abstract Closure with no parameters) and
returns unused. It performs the following steps when called:
Assert:
generator.[[GeneratorState]] is
suspended-start.
NOTE: Once a generator enters the completed state it
never leaves it and its associated execution
context is never resumed. Any execution state
associated with acGenerator can be discarded at this point.
The abstract operation GeneratorValidate takes arguments generator (an ECMAScript language value) and
generatorBrand (a String or empty) and returns either a
normal completion
containing one of suspended-start,
suspended-yield, or completed, or a throw completion. It
performs the following steps when called:
Resume the suspended evaluation of
genContext using NormalCompletion(value)
as the result of the operation that suspended it. Let result be the value
returned by the resumed computation.
NOTE: Once a generator enters the completed state it
never leaves it and its associated execution
context is never resumed. Any execution state
associated with generator can be discarded at this point.
Resume the suspended evaluation of
genContext using abruptCompletion as the result of
the operation that suspended it. Let result be the Completion
Record returned by the resumed computation.
Resume callerContext passing NormalCompletion(iteratorResult).
If genContext is ever resumed again, let resumptionValue be
the Completion
Record with which it is resumed.
The abstract operation CreateIteratorFromClosure takes arguments closure (an
Abstract Closure with no parameters),
generatorBrand (a String or empty), and
generatorPrototype (an Object) and optional argument extraSlots (a
List of names of
internal slots) and returns a Generator. It performs the following steps when called:
AsyncGenerator instances directly inherit properties from the initial value of the
"prototype" property of the async generator function that created the instance.
AsyncGenerator instances indirectly inherit properties from %AsyncGeneratorPrototype%.
Records
which represent requests to resume the async generator. Except during state
transitions, it is non-empty if and only if [[AsyncGeneratorState]] is either
executing or draining-queue.
[[GeneratorBrand]]
a String or empty
A brand used to distinguish different kinds of async generators. The [[GeneratorBrand]] of async generators declared by
ECMAScript source text is
always empty.
27.6.3 AsyncGenerator Abstract Operations
27.6.3.1 AsyncGeneratorRequest Records
An AsyncGeneratorRequest is a
Record value used to
store information about how an async generator should be resumed and contains capabilities
for fulfilling or rejecting the corresponding promise.
The abstract operation AsyncGeneratorStart takes arguments generator (an
AsyncGenerator) and generatorBody (a FunctionBodyParse
Node or an Abstract Closure with no parameters) and
returns unused. It performs the following steps when called:
Assert:
generator.[[AsyncGeneratorState]] is
suspended-start.
The abstract operation AsyncGeneratorEnqueue takes arguments generator (an
AsyncGenerator), completion (a Completion Record),
and promiseCapability (a PromiseCapability
Record) and returns unused. It performs the
following steps when called:
Let request be AsyncGeneratorRequest
{ [[Completion]]: completion, [[Capability]]: promiseCapability }.
Append request to generator.[[AsyncGeneratorQueue]].
The abstract operation AsyncGeneratorCompleteStep takes arguments generator (an
AsyncGenerator), completion (a Completion Record),
and done (a Boolean) and optional argument realm (a Realm
Record) and returns unused. It performs the
following steps when called:
Assert:
generator.[[AsyncGeneratorQueue]] is not empty.
Let next be the first element of generator.[[AsyncGeneratorQueue]].
Remove the first element from generator.[[AsyncGeneratorQueue]].
The abstract operation AsyncGeneratorResume takes arguments generator (an
AsyncGenerator) and completion (a Completion Record)
and returns unused. It performs the following steps when called:
Assert:
generator.[[AsyncGeneratorState]] is either
suspended-start or suspended-yield.
Let genContext be generator.[[AsyncGeneratorContext]].
Resume the suspended evaluation of
genContext using completion as the result of the
operation that suspended it. Let result be the Completion
Record returned by the resumed computation.
The abstract operation AsyncGeneratorAwaitReturn takes argument generator (an
AsyncGenerator) and returns unused. It performs the following steps
when called:
Assert:
generator.[[AsyncGeneratorState]] is
draining-queue.
The abstract operation AsyncGeneratorDrainQueue takes argument generator (an
AsyncGenerator) and returns unused. It drains the generator's
AsyncGeneratorQueue until it encounters an AsyncGeneratorRequest which
holds a return completion.
It performs the following steps when called:
Assert:
generator.[[AsyncGeneratorState]] is
draining-queue.
Let queue be generator.[[AsyncGeneratorQueue]].
Repeat, while queue is not empty,
Let next be the first element of queue.
Let completion be Completion(next.[[Completion]]).
The abstract operation CreateAsyncIteratorFromClosure takes arguments closure (an
Abstract Closure with no parameters),
generatorBrand (a String or empty), and
generatorPrototype (an Object) and returns an AsyncGenerator. It performs the
following steps when called:
creates and initializes a new AsyncFunction when called as a function rather than as a
constructor. Thus the function call
AsyncFunction(…) is equivalent to the object creation expression
new AsyncFunction(…) with the same arguments.
may be used as the value of an extends clause of a class definition. Subclass
constructors that intend to inherit the specified
AsyncFunction behaviour must include a super call to the AsyncFunction
constructor to create and initialize a subclass
instance with the internal slots necessary for built-in async function behaviour. All
ECMAScript syntactic forms for defining async function objects create direct
instances of AsyncFunction. There is no syntactic means to create instances of AsyncFunction
subclasses.
The initial value of the %Symbol.toStringTag% property is the
String value "AsyncFunction".
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: true }.
27.7.4 AsyncFunction Instances
Every AsyncFunction instance is an ECMAScript function object and has the
internal slots listed in Table
30. The value of the [[IsClassConstructor]]
internal slot for all such instances is false. AsyncFunction instances are
not constructors and do not have a [[Construct]] internal method. AsyncFunction instances do not have a
prototype property as they are not constructable.
Each AsyncFunction instance has the following own properties:
27.7.4.1 length
The specification for the "length" property of Function instances given in
20.2.4.1 also applies to
AsyncFunction instances.
27.7.4.2 name
The specification for the "name" property of Function instances given in
20.2.4.2 also applies to
AsyncFunction instances.
The abstract operation AsyncBlockStart takes arguments promiseCapability (a
PromiseCapability Record),
asyncBody (a Parse Node or an Abstract
Closure with no parameters), and asyncContext (an
execution context) and returns
unused. It performs the following steps when called:
Set the code evaluation state of asyncContext such that when evaluation
is resumed for that execution context,
closure will be called with no arguments.
Assert:
result is a normal
completion with a value of unused. The
possible sources of this value are Await or, if the async function doesn't await
anything, step 2.i above.
A Module Namespace Object is a module namespace exotic object that
provides runtime property-based access to a module's exported bindings. There is no constructor function
for Module Namespace Objects. Instead, such an object is created for each module that is imported by
an ImportDeclaration that
contains a NameSpaceImport.
In addition to the properties specified in 10.4.6 each Module
Namespace Object has the following own property:
28.3.1 %Symbol.toStringTag%
The initial value of the %Symbol.toStringTag% property is the
String value "Module".
This property has the attributes { [[Writable]]:
false, [[Enumerable]]: false,
[[Configurable]]: false }.
29 Memory Model
The memory consistency model, or memory model, specifies the possible orderings
of Shared Data Block events, arising via
accessing TypedArray
instances backed by a SharedArrayBuffer and via methods on the Atomics object. When the program has no
data races (defined below), the ordering of events appears as sequentially consistent, i.e., as an
interleaving of actions from each agent. When the program has data races, shared memory operations
may appear sequentially inconsistent. For example, programs may exhibit causality-violating behaviour
and other astonishments. These astonishments arise from compiler transforms and the design of CPUs
(e.g., out-of-order execution and speculation). The memory model defines both the precise conditions
under which a program exhibits sequentially consistent behaviour as well as the possible values read
from data races. To wit, there is no undefined behaviour.
The memory model is defined as relational constraints on events introduced by abstract operations on
SharedArrayBuffer or by methods on the Atomics object during an evaluation.
Note
This section provides an axiomatic model on events introduced by the abstract operations
on SharedArrayBuffers. It bears stressing that the model is not expressible algorithmically,
unlike the rest of this specification. The nondeterministic introduction of events by abstract operations
is the interface between the operational semantics of ECMAScript evaluation and the axiomatic
semantics of the memory model. The semantics of these events is defined by considering graphs of
all events in an evaluation. These are neither Static Semantics nor Runtime Semantics. There is
no demonstrated algorithmic implementation, but instead a set of constraints that determine if a
particular event graph is allowed or disallowed.
29.1 Memory Model Fundamentals
Shared memory accesses (reads and writes) are divided into two groups, atomic accesses and data
accesses, defined below. Atomic accesses are sequentially consistent, i.e., there is a strict total
ordering of events agreed upon by all agents in an agent cluster. Non-atomic accesses
do not have a strict total ordering agreed upon by all agents, i.e., unordered.
Note 1
No orderings weaker than sequentially consistent and stronger than unordered, such as
release-acquire, are supported.
A Shared Data Block event is either a
ReadSharedMemory, WriteSharedMemory, or ReadModifyWriteSharedMemory Record.
These events are introduced by abstract
operations or by methods on the Atomics object.
Some operations may also introduce Synchronize events. A Synchronize event has no fields, and exists
purely to directly constrain the permitted orderings of other events.
In addition to Shared
Data Block and Synchronize events, there are host-specific events.
Let the range of a ReadSharedMemory, WriteSharedMemory, or ReadModifyWriteSharedMemory event be the
Set of contiguous integers from its [[ByteIndex]] to
[[ByteIndex]] + [[ElementSize]] - 1. Two events'
ranges are equal when the events have the same [[Block]], and the ranges
are element-wise equal. Two events' ranges are overlapping when the events have the same [[Block]], the ranges are not equal and their intersection is non-empty. Two
events' ranges are disjoint when the events do not have the same [[Block]]
or their ranges are neither equal nor overlapping.
Note 2
Examples of host-specific synchronizing events that should be
accounted for are: sending a SharedArrayBuffer from one agent to another (e.g., by
postMessage in a browser), starting and stopping agents, and communicating within the
agent
cluster via channels other than shared memory. For a particular
execution execution, those events are provided by the host via the host-synchronizes-withstrict partial order.
Additionally, hosts
can add host-specific
synchronizing events to execution.[[EventList]] so as to
participate in the is-agent-order-beforeRelation.
An empty candidate execution is a
candidate execution Record whose fields are empty
Lists.
29.5 Abstract Operations for the Memory Model
29.5.1 EventSet ( execution )
The abstract operation EventSet takes argument execution (a candidate execution) and returns a Set
of events. It performs the following steps when called:
The abstract operation SharedDataBlockEventSet takes argument execution (a candidate execution) and returns a Set
of events. It performs the following steps when called:
The abstract operation HostEventSet takes argument execution (a candidate execution) and returns a Set
of events. It performs the following steps when called:
Let bytesModified be W.[[ModifyOp]](bytes, W.[[Payload]]).
Let byte be
bytesModified[payloadIndex].
Append byte to bytesRead.
Set byteLocation to byteLocation + 1.
Return bytesRead.
Note 1
The read-modify-write modification [[ModifyOp]] is given by the
function properties on the Atomics object that introduce ReadModifyWriteSharedMemory
events.
For events E and D, E is-agent-order-before D in
execution if there is some Agent Events Recordaer in execution.[[EventsRecords]] such that
aer.[[EventList]] contains both E and
D and E is before D in List order of
aer.[[EventList]].
For events R and W, R reads-from W in
execution if SharedDataBlockEventSet(execution)
contains both R and W, and reads-bytes-from(R) in
execution contains W.
For events R and W, W synchronizes-with R in
execution if Rreads-fromW in
execution, R.[[Order]] is
seq-cst, W.[[Order]] is
seq-cst, and R and W have equal ranges.
For each element eventsRecord of execution.[[EventsRecords]], the following is true.
For events S and Sw, S synchronizes-with
Sw in execution if eventsRecord.[[AgentSynchronizesWith]] contains (S,
Sw).
For events E and D, E synchronizes-with D in
execution if execution.[[HostSynchronizesWith]] contains (E, D).
Note 1
Owing to convention in memory model literature, in a candidate executionexecution, write events synchronizes-with read events, instead of read events
synchronizes-with write events.
In a candidate executionexecution, not all seq-cst events related by reads-from are related by
synchronizes-with. Only events that also have equal ranges are related by
synchronizes-with.
Assert: The remainder of dividing
R.[[ByteIndex]] by R.[[ElementSize]] is 0.
For each event W such that Rreads-fromW in
execution and W.[[NoTear]] is true, do
If R and W have equal ranges and there
exists an event V such that V and
W have equal ranges, V.[[NoTear]] is true,
W and V are not the same Shared Data Block
event, and Rreads-fromV in execution, then
Return false.
Return true.
Note
An event's [[NoTear]] field is true when that
event was introduced via accessing an integerTypedArray, and
false when introduced via accessing a floating point TypedArray
or DataView.
Intuitively, this requirement says when a memory range is accessed in an aligned fashion
via an integerTypedArray, a single write
event on that range must "win" when in a data race with other write
events with equal ranges. More precisely, this requirement says an aligned read event
cannot read a value composed of bytes from multiple, different write events all with
equal ranges. It is possible, however, for an aligned read event to read from multiple
write events with overlapping ranges.
For events E and D, E is-memory-order-before D
in execution if Ehappens-beforeD
in execution.
For events R and W such that Rreads-fromW in
execution, there is no WriteSharedMemory or
ReadModifyWriteSharedMemory
event V in SharedDataBlockEventSet(execution)
such that V.[[Order]] is
seq-cst, W is-memory-order-before V in
execution, V is-memory-order-before R in
execution, and any of the following conditions are true.
This clause together with the forward progress guarantee on agents ensure
the liveness condition that seq-cst writes become visible
to seq-cst reads with equal range in finite time.
While is-memory-order-before includes all events in EventSet(execution), those that
are not constrained by happens-before or synchronizes-with in
execution are allowed to occur anywhere in the order.
29.7.5 Valid Executions
A candidate executionexecution
is a valid execution (or simply an execution) if all of the following are true.
For an execution execution and events E and D that are contained in
SharedDataBlockEventSet(execution),
E and D are in a race if the following algorithm returns
true.
For an execution execution and events E and D that are contained in
SharedDataBlockEventSet(execution),
E and D are in a data race if the following algorithm
returns true.
If E.[[Order]] is not
seq-cst or D.[[Order]] is
not seq-cst, then
Return true.
If E and D have overlapping ranges, then
Return true.
Return false.
29.10 Data Race Freedom
An execution execution is data race free if there are no two
events in SharedDataBlockEventSet(execution)
that are in a data
race.
A program is data race free if all its executions are data race free.
The memory
model guarantees sequential consistency of all events for data race free
programs.
29.11 Shared Memory Guidelines
Note 1
The following are guidelines for ECMAScript programmers working with shared memory.
We recommend programs be kept data race free, i.e., make it so that
it is impossible for there to be concurrent non-atomic operations on the same memory
location. Data race free programs have
interleaving semantics where each step in the evaluation semantics of each agent are interleaved with
each other. For data race free programs, it is not
necessary to understand the details of the memory model. The details are
unlikely to build intuition that will help one to better write ECMAScript.
More generally, even if a program is not data race free it may
have predictable behaviour, so long as atomic operations are not involved in any data races
and the operations that race all have the same access size. The simplest way to arrange for
atomics not to be involved in races is to ensure that different memory cells are used by
atomic and non-atomic operations and that atomic accesses of different sizes are not used to
access the same cells at the same time. Effectively, the program should treat shared memory
as strongly typed as much as possible. One still cannot depend on the ordering and timing of
non-atomic accesses that race, but if memory is treated as strongly typed the racing
accesses will not "tear" (bits of their values will not be mixed).
Note 2
The following are guidelines for ECMAScript implementers writing compiler transformations for
programs using shared memory.
It is desirable to allow most program transformations that are valid in a single-agent setting in a
multi-agent setting,
to ensure that the performance of each agent in a multi-agent program is as good as it would be
in a single-agent
setting. Frequently these transformations are hard to judge. We outline some rules about
program transformations that are intended to be taken as normative (in that they are implied
by the memory
model or stronger than what the memory model implies) but
which are likely not exhaustive. These rules are intended to apply to program
transformations that precede the introductions of the events that make up the is-agent-order-beforeRelation.
Let possible read values of a read event be the set of all values of
ValueOfReadEvent for that event across
all valid executions.
Any transformation of an agent-order slice that is valid in the absence of shared memory is
valid in the presence of shared memory, with the following exceptions.
Atomics are carved in stone: Program transformations must not cause the
seq-cst events in an agent-order slice to be reordered with
its unordered operations, nor its
seq-cst operations to be reordered with each other, nor may a
program transformation remove a seq-cst operation from the
is-agent-order-beforeRelation.
(In practice, the prohibition on reorderings forces a compiler to assume that every
seq-cst operation is a synchronization and included in the
final is-memory-order-beforeRelation,
which it would usually have to assume anyway in the absence of inter-agent program
analysis. It also forces the compiler to assume that every call where the callee's
effects on the memory-order are unknown may contain seq-cst
operations.)
Reads must be stable: Any given shared memory read must only observe a
single value in an execution.
(For example, if what is semantically a single read in the program is executed
multiple times then the program is subsequently allowed to observe only one of the
values read. A transformation known as rematerialization can violate this rule.)
Writes must be stable: All observable writes to shared memory must follow
from program semantics in an execution.
(For example, a transformation may not introduce certain observable writes, such as
by using read-modify-write operations on a larger location to write a smaller datum,
writing a value to memory that the program could not have written, or writing a
just-read value back to the location it was read from, if that location could have
been overwritten by another agent after the read.)
Possible read values must be non-empty: Program transformations cannot cause
the possible read values of a shared memory read to become empty.
(Counterintuitively, this rule in effect restricts transformations on writes, because
writes have force in memory model insofar as to be read
by read events. For example, writes may be moved and coalesced and sometimes
reordered between two seq-cst operations, but the
transformation may not remove every write that updates a location; some write must
be preserved.)
Examples of transformations that remain valid are: merging multiple non-atomic reads from the
same location, reordering non-atomic reads, introducing speculative non-atomic reads,
merging multiple non-atomic writes to the same location, reordering non-atomic writes to
different locations, and hoisting non-atomic reads out of loops even if that affects
termination. Note in general that aliased TypedArrays make it hard to prove that locations
are different.
Note 3
The following are guidelines for ECMAScript implementers generating machine code for shared
memory accesses.
For architectures with memory models no weaker than those of ARM or Power, non-atomic stores
and loads may be compiled to bare stores and loads on the target architecture. Atomic stores
and loads may be compiled down to instructions that guarantee sequential consistency. If no
such instructions exist, memory barriers are to be employed, such as placing barriers on
both sides of a bare store or load. Read-modify-write operations may be compiled to
read-modify-write instructions on the target architecture, such as
LOCK-prefixed instructions on x86, load-exclusive/store-exclusive instructions
on ARM, and load-link/store-conditional instructions on Power.
Specifically, the memory model is intended to allow code
generation as follows.
Every atomic operation in the program is assumed to be necessary.
Atomic operations are never rearranged with each other or with non-atomic operations.
Functions are always assumed to perform atomic operations.
Atomic operations are never implemented as read-modify-write operations on larger data,
but as non-lock-free atomics if the platform does not have atomic operations of the
appropriate size. (We already assume that every platform has normal memory access
operations of every interesting size.)
Naive code generation uses these patterns:
Regular loads and stores compile to single load and store instructions.
Lock-free atomic loads and stores compile to a full (sequentially consistent) fence, a
regular load or store, and a full fence.
Lock-free atomic read-modify-write accesses compile to a full fence, an atomic
read-modify-write instruction sequence, and a full fence.
Non-lock-free atomics compile to a spinlock acquire, a full fence, a series of
non-atomic load and store instructions, a full fence, and a spinlock release.
That mapping is correct so long as an atomic operation on an address range does not race with
a non-atomic write or with an atomic operation of different size. However, that is all we
need: the memory model effectively demotes the atomic
operations involved in a race to non-atomic status. On the other hand, the naive mapping is
quite strong: it allows atomic operations to be used as sequentially consistent fences,
which the memory model does not actually guarantee.
Local improvements to those basic patterns are also allowed, subject to the constraints of
the memory
model. For example:
There are obvious platform-dependent improvements that remove redundant fences. For
example, on x86 the fences around lock-free atomic loads and stores can always be
omitted except for the fence following a store, and no fence is needed for lock-free
read-modify-write instructions, as these all use LOCK-prefixed
instructions. On many platforms there are fences of several strengths, and weaker fences
can be used in certain contexts without destroying sequential consistency.
Most modern platforms support lock-free atomics for all the data sizes required by
ECMAScript atomics. Should non-lock-free atomics be needed, the fences surrounding the
body of the atomic operation can usually be folded into the lock and unlock steps. The
simplest solution for non-lock-free atomics is to have a single lock word per
SharedArrayBuffer.
There are also more complicated platform-dependent local improvements, requiring some
code analysis. For example, two back-to-back fences often have the same effect as a
single fence, so if code is generated for two atomic operations in sequence, only a
single fence need separate them. On x86, even a single fence separating atomic stores
can be omitted, as the fence following a store is only needed to separate the store from
a subsequent load.
Annex B (normative) Additional ECMAScript
Features for Web Browsers
The ECMAScript language syntax and semantics defined in this annex are required when the ECMAScript
host is a web browser. The content
of this annex is normative but optional if the ECMAScript host is not a web browser.
Note
This annex describes various legacy features and other characteristics of web browser ECMAScript
hosts. All of the language
features and behaviours specified in this annex have one or more undesirable characteristics and
in the absence of legacy usage would be removed from this specification. However, the usage of
these features by large numbers of existing web pages means that web browsers must continue to
support them. The specifications in this annex define the requirements for interoperable
implementations of these legacy features.
These features are not considered part of the core ECMAScript language. Programmers should not
use or assume the existence of these features and behaviours when writing new ECMAScript code.
ECMAScript implementations are discouraged from implementing these features unless the
implementation is part of a web browser or is required to run the same legacy ECMAScript code
that web browsers encounter.
B.1 Additional Syntax
B.1.1 HTML-like Comments
The syntax and semantics of 12.4 is extended as follows except that this
extension is not allowed when parsing source text using the goal
symbolModule:
The syntax of 22.2.1 is modified and extended as follows. These
changes introduce ambiguities that are broken by the ordering of grammar productions and by
contextual information. When parsing using the following grammar, each alternative is considered
only if previous production alternatives do not match.
This alternative pattern grammar and semantics only changes the syntax and semantics of BMP
patterns. The following grammar extensions include productions parameterized with the
[UnicodeMode] parameter. However, none of these extensions change the syntax of Unicode patterns
recognized when parsing with the [UnicodeMode] parameter present on the goal
symbol.
Return the CharSet containing the single
character \ U+005C (REVERSE SOLIDUS).
Note
This production can only be reached from the sequence
\c within a character class where it is not followed by an acceptable
control character.
B.1.2.8.1 CharacterRangeOrUnion ( rer,
A, B )
The abstract operation CharacterRangeOrUnion takes arguments rer (a RegExp
Record), A (a CharSet), and B
(a CharSet) and returns a CharSet. It performs the following steps
when called:
The abstract operation ParsePattern takes arguments
patternText (a sequence of Unicode code points), u (a Boolean), and
v (a Boolean). It performs the following steps when called:
If v is true and u is
true, then
Let parseResult be a List
containing one or more SyntaxError objects.
Else if v is true, then
Let parseResult be ParseText(patternText,
Pattern[+UnicodeMode,
+UnicodeSetsMode,
+NamedCaptureGroups]).
Else if u is true, then
Let parseResult be ParseText(patternText,
Pattern[+UnicodeMode,
~UnicodeSetsMode,
+NamedCaptureGroups]).
Else,
Let parseResult be ParseText(patternText,
Pattern[~UnicodeMode,
~UnicodeSetsMode,
~NamedCaptureGroups]).
This function is a property of the global object. It computes a new version of
a String value in which certain code units have been replaced by a hexadecimal escape
sequence.
When replacing a code unit of numeric value less than or equal to 0x00FF, a two-digit escape
sequence of the form %xx is used. When replacing a code unit of
numeric value strictly greater than 0x00FF, a four-digit escape sequence of the form
%uxxxx is used.
The encoding is partly based on the encoding described in RFC 1738, but the entire
encoding specified in this standard is described above without regard to the
contents of RFC 1738. This encoding does not reflect changes to RFC 1738 made by RFC
3986.
B.2.1.2 unescape ( string )
This function is a property of the global object. It computes a new version of
a String value in which each escape sequence of the sort that might be introduced by the
escape function is replaced with the code unit that it represents.
B.2.2 Additional Properties of the String.prototype Object
B.2.2.1 String.prototype.substr ( start,
length )
This method returns a substring of the result of converting the
this value to a String, starting from index start and running
for length code units (or through the end of the String if length is
undefined). If start is negative, it is treated as sourceLength + start where
sourceLength is the length of the String. The result is a String value,
not a String object.
Return the substring of S from
intStart to intEnd.
Note
This method is intentionally generic; it does not require that its
this value be a String object. Therefore it can be transferred to
other kinds of objects for use as a method.
B.2.2.2 String.prototype.anchor ( name )
This method performs the following steps when called:
Let escapedV be the String value that is the same as
V except that each occurrence of the code unit 0x0022
(QUOTATION MARK) in V has been replaced with the six code
unit sequence """.
The property "trimStart" is preferred. The
"trimLeft" property is provided principally for compatibility
with old code. It is recommended that the "trimStart" property be
used in new ECMAScript code.
The initial value of the "trimLeft" property is
%String.prototype.trimStart%, defined in 22.1.3.34.
B.2.2.16 String.prototype.trimRight ( )
Note
The property "trimEnd" is preferred. The
"trimRight" property is provided principally for compatibility
with old code. It is recommended that the "trimEnd" property be
used in new ECMAScript code.
The initial value of the "trimRight" property is
%String.prototype.trimEnd%, defined in 22.1.3.33.
B.2.3 Additional Properties of the Date.prototype Object
B.2.3.1 Date.prototype.getYear ( )
Note
The getFullYear method is preferred for nearly all purposes, because it
avoids the “year 2000 problem.”
This method performs the following steps when called:
This method completely reinitializes the this value RegExp with a
new pattern and flags. An implementation may interpret use of this method as an
assertion that the resulting RegExp object will be used multiple times and hence is
a candidate for extra optimization.
B.3 Other Additional Features
B.3.1 Labelled Function Declarations
Prior to ECMAScript 2015, the specification of LabelledStatement did not allow for the
association of a statement label with a FunctionDeclaration. However, a labelled
FunctionDeclaration was
an allowable extension for non-strict code and most browser-hosted
ECMAScript implementations supported that extension. In ECMAScript 2015 and later, the grammar
production for LabelledStatement permits use of FunctionDeclaration as a
LabelledItem but 14.13.1
includes an Early Error rule that produces a Syntax Error if that occurs. That rule is modified
with the addition of the highlighted text:
B.3.2 Block-Level Function Declarations Web Legacy Compatibility
Semantics
Prior to ECMAScript 2015, the ECMAScript specification did not define the occurrence of a FunctionDeclaration as an
element of a Block statement's
StatementList. However,
support for that form of FunctionDeclaration was an allowable
extension and most browser-hosted ECMAScript implementations permitted them. Unfortunately, the
semantics of such declarations differ among those implementations. Because of these semantic
differences, existing web ECMAScript source text that uses Block level function declarations is only
portable among browser implementations if the usage only depends upon the semantic intersection
of all of the browser implementations for such declarations. The following are the use cases
that fall within that intersection semantics:
A function is declared and only referenced within a single block.
One or more FunctionDeclarations whose
BindingIdentifier is the name
f occur within the function code of an enclosing function g
and that declaration is nested within a Block.
No other declaration of f that is not a var declaration
occurs within the function code of g.
A function is declared and possibly used within a single Block but also referenced by an inner function
definition that is not contained within that same Block.
One or more FunctionDeclarations whose
BindingIdentifier is the name
f occur within the function code of an enclosing function g
and that declaration is nested within a Block.
No other declaration of f that is not a var declaration
occurs within the function code of g.
There is at least one occurrence of f as an IdentifierReference within
another function h that is nested within g and no other
declaration of f shadows the references to f from within
h.
All invocations of h occur after the declaration of f has been
evaluated.
A function is declared and possibly used within a single block but also referenced within
subsequent blocks.
One or more FunctionDeclaration whose
BindingIdentifier is the name
f occur within the function code of an enclosing function g
and that declaration is nested within a Block.
No other declaration of f that is not a var declaration
occurs within the function code of g.
There is at least one occurrence of f as an IdentifierReference within the
function code of g that lexically follows the Block containing the declaration of
f.
The first use case is interoperable with the semantics of Block level function declarations provided by ECMAScript
2015. Any pre-existing ECMAScript source text that employs that use case
will operate using the Block level function declarations semantics defined by clauses 10, 14, and
15.
ECMAScript 2015 interoperability for the second and third use cases requires the following
extensions to the clause 10,
clause 15, clause
19.2.1 and
clause 16.1.7 semantics.
If an ECMAScript implementation has a mechanism for reporting diagnostic warning messages, a
warning should be produced when code contains a FunctionDeclaration for which these
compatibility semantics are applied and introduce observable differences from non-compatibility
semantics. For example, if a var binding is not introduced because its introduction would create
an early
error, a warning message should not be produced.
B.3.2.1 Changes to FunctionDeclarationInstantiation
NOTE: A var binding for F is only instantiated
here if it is neither a VarDeclaredName, the name of a
formal parameter, or another FunctionDeclaration.
If instantiatedVarNames does not contain
F and F is not
"arguments", then
It is a Syntax Error if the LexicallyDeclaredNames
of StatementList
contains any duplicate entries, unless IsStrict(this production) is
false and the duplicate entries are only bound by
FunctionDeclarations.
It is a Syntax Error if the LexicallyDeclaredNames
of CaseBlock contains any
duplicate entries, unless IsStrict(this production) is
false and the duplicate entries are only bound by
FunctionDeclarations.
The Block of a Catch clause may contain
var declarations that bind a name that is also bound by the CatchParameter. At
runtime, such bindings are instantiated in the VariableDeclarationEnvironment. They do
not shadow the same-named bindings introduced by the CatchParameter and hence the Initializer for such
var declarations will assign to the corresponding catch parameter rather
than the var binding.
This modified behaviour also applies to var and function declarations
introduced by direct
eval calls contained within the Block of a Catch clause. This change is accomplished by modifying
the algorithm of 19.2.1.3 as follows:
Objects with an [[IsHTMLDDA]] internal slot are never created by
this specification. However, the document.all
object in web browsers is a host-definedexotic object with this slot
that exists for web compatibility purposes. There are no other known examples of this
type of object and implementations should not create any with the exception of
document.all.
B.3.9 Runtime Errors for Function Call Assignment Targets
When a function call (13.3.6) is used as an assignment target in
non-strict
code, instead of producing an early error, a
ReferenceError exception is thrown during evaluation of the assignment.
Note
When the assignment target is the LeftHandSideExpression of an
AssignmentExpression, the
assignment operator must be = or an AssignmentOperator; in particular,
the allowance here does not apply to the logical assignment operators (??=,
&&=, ||=).
Assignment to an undeclared identifier or otherwise unresolvable reference does not create a
property in the global object. When a simple assignment occurs
within strict
mode code, its LeftHandSideExpression must not evaluate to
an unresolvable Reference. If it does a ReferenceError exception is thrown
(6.2.5.6). The
LeftHandSideExpression
also may not be a reference to a data property with the attribute value { [[Writable]]: false }, to an accessor
property with the attribute value { [[Set]]:
undefined }, nor to a non-existent property of an object whose [[Extensible]] internal slot is false. In these cases a
TypeError exception is thrown (13.15).
Arguments objects for strict functions do not dynamically share their
array-indexed
property values with the corresponding formal parameter bindings of their functions. (10.4.4).
For strict
functions, if an arguments object is created the binding of the local
identifier arguments to the arguments object is immutable and hence may not be the
target of an assignment expression. (10.2.11).
Strict mode eval code cannot instantiate variables or functions in the variable environment of the
caller to eval. Instead, a new variable environment is created and that environment is used for
declaration binding instantiation for the eval code (19.2.1).
If this is evaluated within strict mode code, then the
this value is not coerced to an object. A this value of either
undefined or null is not converted to the global
object and primitive values are not converted to wrapper objects. The
this value passed via a function call (including calls made using
Function.prototype.apply and Function.prototype.call) do not coerce the
passed this value to an object (10.2.1.2, 20.2.3.1, 20.2.3.3).
When a delete operator occurs within strict mode code, a
SyntaxError is thrown if its UnaryExpression is a direct reference to a
variable, function argument, or function name (13.5.1.1).
When a delete operator occurs within strict mode code, a
TypeError is thrown if the property to be deleted has the attribute { [[Configurable]]: false } or otherwise cannot be deleted
(13.5.1.2).
An implementation may not extend, beyond that defined in this specification, the meanings within
strict
functions of properties named "caller" or
"arguments" of function instances.
Preparation steps before, and cleanup steps after, invocation of JobAbstract Closures. See 9.5.
D.5 Internal Methods of Exotic Objects
Any of the essential internal methods in Table 4 for any
exotic
object not specified within this specification.
D.6 Built-in Objects and Methods
Any built-in objects and methods not defined within this specification, except as restricted in
17.1.
Annex E (informative) Corrections and
Clarifications in ECMAScript 2015 with Possible Compatibility Impact
9.1.1.4.14-9.1.1.4.17 Edition 5 and 5.1 used a
property existence test to determine whether a global object property corresponding to a new global
declaration already existed. ECMAScript 2015 uses an own property existence test. This corresponds to
what has been most commonly implemented by web browsers.
10.4.2.1: The
5th Edition moved the capture of the current array length prior to the integer conversion of the
array index or new
length value. However, the captured length value could become invalid if the conversion process has the
side-effect of changing the array length. ECMAScript 2015 specifies that the current array length must
be captured after the possible occurrence of such side-effects.
21.4.1.31: Previous
editions permitted the TimeClip abstract operation to return either
+0𝔽 or -0𝔽 as the representation of a 0
time value. ECMAScript 2015 specifies that
+0𝔽 always returned. This means that for ECMAScript 2015 the time value of a Date is never observably
-0𝔽 and methods that return time values never return
-0𝔽.
21.4.1.32: If a UTC offset representation is
not present, the local time zone is used. Edition 5.1 incorrectly stated that a missing time zone should
be interpreted as "z".
21.4.4.36: If the year cannot be
represented using the Date Time String Format specified in 21.4.1.32 a RangeError exception
is thrown. Previous editions did not specify the behaviour for that case.
21.4.4.41: Previous editions did not specify
the value returned by Date.prototype.toString when the time value is NaN.
ECMAScript 2015 specifies the result to be the String value "Invalid Date".
22.2.4.1, 22.2.6.13.1: Any LineTerminator code points in
the value of the "source" property of a RegExp instance must be expressed using an
escape sequence. Edition 5.1 only required the escaping of /.
22.2.6.8, 22.2.6.11: In previous editions,
the specifications for String.prototype.match and String.prototype.replace was
incorrect for cases where the pattern argument was a RegExp value whose global flag is set.
The previous specifications stated that for each attempt to match the pattern, if lastIndex
did not change, it should be incremented by 1. The correct behaviour is that lastIndex
should be incremented by 1 only if the pattern matched the empty String.
23.1.3.30: Previous editions did not specify how
a NaN value returned by a comparator was interpreted by
Array.prototype.sort. ECMAScript 2015 specifies that such as value is treated as if
+0𝔽 was returned from the comparator. ECMAScript 2015 also
specifies that ToNumber
is applied to the result returned by a comparator. In previous editions, the effect of a
comparator result that is not a Number
value was implementation-defined. In practice,
implementations call ToNumber.
Annex F (informative) Additions and Changes
That Introduce Incompatibilities with Prior Editions
6.2.5: In ECMAScript 2015,
Function calls are not allowed to return a Reference Record.
9.3: In
ECMAScript 2018, Template objects are canonicalized based on Parse Node (source location),
instead of across all occurrences of that template literal or tagged template in a Realm in previous editions.
12.2: In
ECMAScript 2016, Unicode 8.0.0 or higher is mandated, as opposed to ECMAScript 2015 which mandated
Unicode 5.1. In particular, this caused U+180E MONGOLIAN VOWEL SEPARATOR, which was in the
Space_Separator (Zs) category and thus treated as whitespace in ECMAScript
2015, to be moved to the Format (Cf) category (as of Unicode 6.3.0). This
causes whitespace-sensitive methods to behave differently. For example,
"\u180E".trim().length was 0 in previous editions, but 1 in
ECMAScript 2016 and later. Additionally, ECMAScript 2017 mandated always using the latest version of the
Unicode Standard.
12.7: In ECMAScript 2015, the valid code points
for an IdentifierName are specified
in terms of the Unicode properties “ID_Start” and “ID_Continue”. In previous editions, the valid IdentifierName or Identifier code points were specified by
enumerating various Unicode code point categories.
12.10.1: In ECMAScript 2015,
Automatic Semicolon Insertion adds a semicolon at the end of a do-while statement if the semicolon is
missing. This change aligns the specification with the actual behaviour of most existing
implementations.
13.2.5.1: In
ECMAScript 2015, it is no longer an early error to have duplicate property names in Object
Initializers.
13.15.1: In
ECMAScript 2015, strict mode code containing an assignment to an
immutable binding such as the function name of a FunctionExpression does not produce an early error. Instead it
produces a runtime error.
14.2: In ECMAScript 2015, a
StatementList beginning with the
token let followed by the input elements LineTerminator then Identifier is the start of a LexicalDeclaration. In previous editions, automatic
semicolon insertion would always insert a semicolon before the Identifier input element.
14.7: In ECMAScript 2015, if the (
token of a for statement is immediately followed by the token sequence let [ then the
let is treated as the start of a LexicalDeclaration. In previous editions such a
token sequence would be the start of an Expression.
14.7: In ECMAScript 2015, if the ( token of a
for-in statement is immediately followed by the token sequence let [ then the
let is treated as the start of a ForDeclaration. In previous editions such a token
sequence would be the start of an LeftHandSideExpression.
14.7: Prior to ECMAScript 2015, an
initialization expression could appear as part of the VariableDeclaration that precedes the
inkeyword. In ECMAScript 2015, the ForBinding in that same position does not
allow the occurrence of such an initializer. In ECMAScript 2017, such an initializer is permitted only
in non-strict
code.
14.15: In
ECMAScript 2015, it is an early
error for a Catch
clause to contain a var declaration for the same Identifier that appears as the Catch clause parameter. In previous editions, such a variable
declaration would be instantiated in the enclosing variable environment but the declaration's Initializer value would be assigned to the
Catch parameter.
14.15,
19.2.1.3: In ECMAScript 2015, a runtime
SyntaxError is thrown if a Catch clause evaluates a non-strict direct eval
whose eval code includes a var or FunctionDeclaration declaration that binds
the same Identifier that appears as the
Catch clause parameter.
15.4.5 In ECMAScript
2015, the function
objects that are created as the values of the [[Get]] or
[[Set]] attribute of accessor properties in an ObjectLiteral are not constructor functions and they do not have a
"prototype" own property. In the previous edition, they were constructors and had a
"prototype" property.
20.1.2.6:
In ECMAScript 2015, if the argument to Object.freeze is not an object it is treated as if
it was a non-extensible ordinary object with no own properties. In the previous
edition, a non-object argument always causes a TypeError to be thrown.
20.1.2.8: In ECMAScript 2015, if the
argument to Object.getOwnPropertyDescriptor is not an object an attempt is made to coerce
the argument using ToObject. If the coercion is successful the result is used
in place of the original argument value. In the previous edition, a non-object argument always causes a
TypeError to be thrown.
20.1.2.10: In ECMAScript 2015, if the
argument to Object.getOwnPropertyNames is not an object an attempt is made to coerce the
argument using ToObject. If the coercion is successful the result is used
in place of the original argument value. In the previous edition, a non-object argument always causes a
TypeError to be thrown.
20.1.2.12: In ECMAScript 2015, if the argument
to Object.getPrototypeOf is not an object an attempt is made to coerce the argument using
ToObject. If the
coercion is successful the result is used in place of the original argument value. In the previous
edition, a non-object argument always causes a TypeError to be thrown.
20.1.2.16: In ECMAScript 2015, if the argument to
Object.isExtensible is not an object it is treated as if it was a non-extensible ordinary object
with no own properties. In the previous edition, a non-object argument always causes a
TypeError to be thrown.
20.1.2.17: In ECMAScript 2015, if the argument to
Object.isFrozen is not an object it is treated as if it was a non-extensible ordinary object
with no own properties. In the previous edition, a non-object argument always causes a
TypeError to be thrown.
20.1.2.18: In ECMAScript 2015, if the argument to
Object.isSealed is not an object it is treated as if it was a non-extensible ordinary object
with no own properties. In the previous edition, a non-object argument always causes a
TypeError to be thrown.
20.1.2.19: In
ECMAScript 2015, if the argument to Object.keys is not an object an attempt is made to
coerce the argument using ToObject. If the coercion is successful the result is used
in place of the original argument value. In the previous edition, a non-object argument always causes a
TypeError to be thrown.
20.1.2.20: In ECMAScript 2015, if the
argument to Object.preventExtensions is not an object it is treated as if it was a
non-extensible ordinary
object with no own properties. In the previous edition, a non-object argument
always causes a TypeError to be thrown.
20.1.2.22: In
ECMAScript 2015, if the argument to Object.seal is not an object it is treated as if it was
a non-extensible ordinary
object with no own properties. In the previous edition, a non-object argument
always causes a TypeError to be thrown.
20.2.3.2: In ECMAScript 2015, the [[Prototype]] internal slot of a bound function is set to the [[GetPrototypeOf]] value of its target function. In the previous edition, [[Prototype]] was always set to %Function.prototype%.
20.2.4.1: In ECMAScript 2015, the
"length" property of function instances is configurable. In previous editions it was
non-configurable.
21.4.4 In ECMAScript 2015,
the Date prototype object is not
a Date instance. In previous editions it was a Date instance whose TimeValue was NaN.
22.1.3.12 In ECMAScript 2015, the
String.prototype.localeCompare function must treat Strings that are canonically equivalent
according to the Unicode Standard as being identical. In previous editions implementations were
permitted to ignore canonical equivalence and could instead use a bit-wise comparison.
22.1.3.28 and 22.1.3.30 In ECMAScript 2015,
lowercase/upper conversion processing operates on code points. In previous editions such the conversion
processing was only applied to individual code units. The only affected code points are those in the
Deseret block of Unicode.
22.1.3.32 In ECMAScript 2015, the
String.prototype.trim method is defined to recognize white space code points that may exist
outside of the Unicode BMP. However, as of Unicode 7 no such code points are defined. In previous
editions such code points would not have been recognized as white space.
22.2.4.1 In ECMAScript 2015, If the
pattern argument is a RegExp instance and the flags argument is not
undefined, a new RegExp instance is created just like pattern except that
pattern's flags are replaced by the argument flags. In previous editions a
TypeError exception was thrown when pattern was a RegExp instance and
flags was not undefined.
22.2.6 In ECMAScript 2015,
the RegExp prototype object is
not a RegExp instance. In previous editions it was a RegExp instance whose pattern is the empty String.
25.4.15:
In ECMAScript 2019, Atomics.wake has been renamed to Atomics.notify to prevent
confusion with Atomics.wait.
27.1.6.4, 27.6.3.6: In ECMAScript 2019, the number of
Jobs enqueued by await
was reduced, which could create an observable difference in resolution order between a
then() call and an await expression.
Bibliography
IEEE 754-2019: IEEE Standard for Floating-Point Arithmetic.
Institute of Electrical and Electronic Engineers, New York (2019)
Note
There are no normative changes between IEEE 754-2008 and IEEE 754-2019 that affect the
ECMA-262 specification.
This specification is authored on GitHub in a plaintext
source format called Ecmarkup. Ecmarkup is an HTML
and Markdown dialect that provides a framework and toolset for authoring ECMAScript specifications in
plaintext and processing the specification into a full-featured HTML rendering that follows the
editorial conventions for this document. Ecmarkup builds on and integrates a number of other formats and
technologies including Grammarkdown for defining
syntax and Ecmarkdown for authoring algorithm steps.
PDF renderings of this specification are produced using a print stylesheet which takes advantage of the
CSS Paged Media specification and is converted using PrinceXML.
Prior editions of this specification were authored using Word—the Ecmarkup source text that formed the
basis of this edition was produced by converting the ECMAScript 2015 Word document to Ecmarkup using an
automated conversion tool.
This draft document may be copied and furnished to others, and derivative works that comment on or
otherwise explain it or assist in its implementation may be prepared, copied, published, and
distributed, in whole or in part, without restriction of any kind, provided that the above copyright
notice and this section are included on all such copies and derivative works. However, this document
itself may not be modified in any way, including by removing the copyright notice or references to
Ecma International, except as needed for the purpose of developing any document or deliverable
produced by Ecma International.
This disclaimer is valid only prior to final version of this document. After approval all rights on
the standard are reserved by Ecma International.
The limited permissions are granted through the standardization phase and will not be revoked by Ecma
International or its successors or assigns during this time.
This document and the information contained herein is provided on an "AS IS" basis and ECMA
INTERNATIONAL DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY
WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY OWNERSHIP RIGHTS OR ANY
IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
Software License
All Software contained in this document ("Software") is protected by copyright and is being made
available under the "BSD License", included below. This Software may be subject to third party rights
(rights from parties other than Ecma International), including patent rights, and no licenses under such
third party rights are granted under this license even if the third party concerned is a member of Ecma
International. SEE THE ECMA CODE OF CONDUCT IN PATENT MATTERS AVAILABLE AT https://ecma-international.org/memento/codeofconduct.htm
FOR INFORMATION REGARDING THE LICENSING OF PATENT CLAIMS THAT ARE REQUIRED TO IMPLEMENT ECMA
INTERNATIONAL STANDARDS.
Redistribution and use in source and binary forms, with or without modification, are permitted provided
that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of conditions and
the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions
and the following disclaimer in the documentation and/or other materials provided with the
distribution.
Neither the name of the authors nor Ecma International may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE ECMA INTERNATIONAL "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ECMA INTERNATIONAL BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.